12fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers/* 22fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * Copyright (C) 2012 The Android Open Source Project 32fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * 42fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * Licensed under the Apache License, Version 2.0 (the "License"); 52fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * you may not use this file except in compliance with the License. 62fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * You may obtain a copy of the License at 72fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * 82fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * http://www.apache.org/licenses/LICENSE-2.0 92fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * 102fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * Unless required by applicable law or agreed to in writing, software 112fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * distributed under the License is distributed on an "AS IS" BASIS, 122fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 132fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * See the License for the specific language governing permissions and 142fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers * limitations under the License. 152fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers */ 162fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers 173cfa4d05afa76e19ca99ec964b535a15c73683f0Andreas Gampe#include "interpreter.h" 18b0fa5dc7769c1e054032f39de0a3f6d6dd06f8cfIan Rogers 19d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz#include <limits> 202dd0e2cea360bc9206eb88ecc40d259e796c239dIan Rogers 21580667b8d9cf6943596efff4df64f5879c1529e3Andreas Gampe#include "common_dex_operations.h" 22103992b9171fac9eceb2fe4015ab04f544b9c559Andreas Gampe#include "common_throws.h" 239e734c7ab4599d7747a05db0dc73c7b668cb6683David Sehr#include "dex/dex_file_types.h" 243cfa4d05afa76e19ca99ec964b535a15c73683f0Andreas Gampe#include "interpreter_common.h" 255e26eb1dc8ea89b2ebf4ce4b40cbe18542758fbdAndreas Gampe#include "interpreter_mterp_impl.h" 265e26eb1dc8ea89b2ebf4ce4b40cbe18542758fbdAndreas Gampe#include "interpreter_switch_impl.h" 27513061a792b22c417c938d31c19581390709561cAndreas Gampe#include "jit/jit.h" 28513061a792b22c417c938d31c19581390709561cAndreas Gampe#include "jit/jit_code_cache.h" 2928bd2e4f151267b34b8e1eb19c489d8d547bbf5cMathieu Chartier#include "jvalue-inl.h" 30b0fa5dc7769c1e054032f39de0a3f6d6dd06f8cfIan Rogers#include "mirror/string-inl.h" 31513061a792b22c417c938d31c19581390709561cAndreas Gampe#include "mterp/mterp.h" 32373a9b5c718a45ac484afcf4fe6ce84f4bb562b3Andreas Gampe#include "nativehelper/scoped_local_ref.h" 330795f23920ee9aabf28e45c63cd592dcccf00216Mathieu Chartier#include "scoped_thread_state_change-inl.h" 34b30259251b22430fad12f1adeab671e4bf8f88f5Andreas Gampe#include "stack.h" 35513061a792b22c417c938d31c19581390709561cAndreas Gampe#include "thread-inl.h" 362969bcdcd80624e4a4fef696b54c2c76b44b6853Andreas Gampe#include "unstarted_runtime.h" 37b0fa5dc7769c1e054032f39de0a3f6d6dd06f8cfIan Rogers 382fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogersnamespace art { 392fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogersnamespace interpreter { 402fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers 41ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu ChartierALWAYS_INLINE static ObjPtr<mirror::Object> ObjArg(uint32_t arg) 42ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier REQUIRES_SHARED(Locks::mutator_lock_) { 43ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier return ObjPtr<mirror::Object>(reinterpret_cast<mirror::Object*>(arg)); 44ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier} 45ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier 46ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartierstatic void InterpreterJni(Thread* self, 47ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ArtMethod* method, 48ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier const StringPiece& shorty, 49ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ObjPtr<mirror::Object> receiver, 50ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier uint32_t* args, 51ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier JValue* result) 52bdf7f1c3ab65ccb70f62db5ab31dba060632d458Andreas Gampe REQUIRES_SHARED(Locks::mutator_lock_) { 5364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler, 5464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers // it should be removed and JNI compiled stubs used instead. 5564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedObjectAccessUnchecked soa(self); 5664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers if (method->IsStatic()) { 5764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers if (shorty == "L") { 58460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jobject (fntype)(JNIEnv*, jclass); 592d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 6064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 6164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 62556d637764b71563030c479bc35364a75188d559Ian Rogers jobject jresult; 63556d637764b71563030c479bc35364a75188d559Ian Rogers { 64556d637764b71563030c479bc35364a75188d559Ian Rogers ScopedThreadStateChange tsc(self, kNative); 65556d637764b71563030c479bc35364a75188d559Ian Rogers jresult = fn(soa.Env(), klass.get()); 66556d637764b71563030c479bc35364a75188d559Ian Rogers } 67ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier result->SetL(soa.Decode<mirror::Object>(jresult)); 6864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "V") { 69460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef void (fntype)(JNIEnv*, jclass); 702d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 7164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 7264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 7364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 7464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers fn(soa.Env(), klass.get()); 7564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "Z") { 76460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jboolean (fntype)(JNIEnv*, jclass); 772d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 7864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 7964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 8064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 8164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers result->SetZ(fn(soa.Env(), klass.get())); 8264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "BI") { 83460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jbyte (fntype)(JNIEnv*, jclass, jint); 842d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 8564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 8664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 8764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 885d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetB(fn(soa.Env(), klass.get(), args[0])); 8964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "II") { 90460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jint (fntype)(JNIEnv*, jclass, jint); 912d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 9264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 9364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 9464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 955d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetI(fn(soa.Env(), klass.get(), args[0])); 9664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "LL") { 97460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jobject (fntype)(JNIEnv*, jclass, jobject); 982d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 9964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 10064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 10164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg0(soa.Env(), 102ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[0]))); 103556d637764b71563030c479bc35364a75188d559Ian Rogers jobject jresult; 104556d637764b71563030c479bc35364a75188d559Ian Rogers { 105556d637764b71563030c479bc35364a75188d559Ian Rogers ScopedThreadStateChange tsc(self, kNative); 106556d637764b71563030c479bc35364a75188d559Ian Rogers jresult = fn(soa.Env(), klass.get(), arg0.get()); 107556d637764b71563030c479bc35364a75188d559Ian Rogers } 108ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier result->SetL(soa.Decode<mirror::Object>(jresult)); 10964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "IIZ") { 110460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jint (fntype)(JNIEnv*, jclass, jint, jboolean); 1112d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 11264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 11364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 11464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1155d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetI(fn(soa.Env(), klass.get(), args[0], args[1])); 11664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "ILI") { 117460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jint (fntype)(JNIEnv*, jclass, jobject, jint); 1182d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(const_cast<void*>( 1192d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier method->GetEntryPointFromJni())); 12064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 12164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 12264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg0(soa.Env(), 123ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[0]))); 12464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1255d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetI(fn(soa.Env(), klass.get(), arg0.get(), args[1])); 12664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "SIZ") { 127460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jshort (fntype)(JNIEnv*, jclass, jint, jboolean); 1282cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier fntype* const fn = 1292cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier reinterpret_cast<fntype*>(const_cast<void*>(method->GetEntryPointFromJni())); 13064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 13164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 13264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1335d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetS(fn(soa.Env(), klass.get(), args[0], args[1])); 13464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "VIZ") { 135460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef void (fntype)(JNIEnv*, jclass, jint, jboolean); 1362d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 13764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 13864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 13964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1405d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao fn(soa.Env(), klass.get(), args[0], args[1]); 14164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "ZLL") { 142460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jboolean (fntype)(JNIEnv*, jclass, jobject, jobject); 1432d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 14464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 14564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 14664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg0(soa.Env(), 147ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[0]))); 14864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg1(soa.Env(), 149ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[1]))); 15064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 15164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers result->SetZ(fn(soa.Env(), klass.get(), arg0.get(), arg1.get())); 15264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "ZILL") { 153460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jboolean (fntype)(JNIEnv*, jclass, jint, jobject, jobject); 1542d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 15564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 15664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 15764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg1(soa.Env(), 158ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[1]))); 15964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg2(soa.Env(), 160ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[2]))); 16164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1625d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetZ(fn(soa.Env(), klass.get(), args[0], arg1.get(), arg2.get())); 16364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "VILII") { 164460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef void (fntype)(JNIEnv*, jclass, jint, jobject, jint, jint); 1652d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 16664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 16764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 16864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg1(soa.Env(), 169ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[1]))); 17064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1715d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao fn(soa.Env(), klass.get(), args[0], arg1.get(), args[2], args[3]); 17264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "VLILII") { 173460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef void (fntype)(JNIEnv*, jclass, jobject, jint, jobject, jint, jint); 1742d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 17564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jclass> klass(soa.Env(), 17664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jclass>(method->GetDeclaringClass())); 17764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg0(soa.Env(), 178ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[0]))); 17964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg2(soa.Env(), 180ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[2]))); 18164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 1825d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao fn(soa.Env(), klass.get(), arg0.get(), args[1], arg2.get(), args[3], args[4]); 18364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else { 184709b070044354d9f47641f273edacaeeb0240ab7David Sehr LOG(FATAL) << "Do something with static native method: " << method->PrettyMethod() 18564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers << " shorty: " << shorty; 18664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } 18764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else { 18864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers if (shorty == "L") { 189460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jobject (fntype)(JNIEnv*, jobject); 1902d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 19164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> rcvr(soa.Env(), 19264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jobject>(receiver)); 193556d637764b71563030c479bc35364a75188d559Ian Rogers jobject jresult; 194556d637764b71563030c479bc35364a75188d559Ian Rogers { 195556d637764b71563030c479bc35364a75188d559Ian Rogers ScopedThreadStateChange tsc(self, kNative); 196556d637764b71563030c479bc35364a75188d559Ian Rogers jresult = fn(soa.Env(), rcvr.get()); 197556d637764b71563030c479bc35364a75188d559Ian Rogers } 198ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier result->SetL(soa.Decode<mirror::Object>(jresult)); 1993dd9f76ff8fa99be9ff6b18354528c5def7b26f7Jeff Hao } else if (shorty == "V") { 200460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef void (fntype)(JNIEnv*, jobject); 2012d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 2023dd9f76ff8fa99be9ff6b18354528c5def7b26f7Jeff Hao ScopedLocalRef<jobject> rcvr(soa.Env(), 2033dd9f76ff8fa99be9ff6b18354528c5def7b26f7Jeff Hao soa.AddLocalReference<jobject>(receiver)); 2043dd9f76ff8fa99be9ff6b18354528c5def7b26f7Jeff Hao ScopedThreadStateChange tsc(self, kNative); 2053dd9f76ff8fa99be9ff6b18354528c5def7b26f7Jeff Hao fn(soa.Env(), rcvr.get()); 20664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "LL") { 207460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jobject (fntype)(JNIEnv*, jobject, jobject); 2082d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 20964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> rcvr(soa.Env(), 21064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jobject>(receiver)); 21164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> arg0(soa.Env(), 212ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier soa.AddLocalReference<jobject>(ObjArg(args[0]))); 213556d637764b71563030c479bc35364a75188d559Ian Rogers jobject jresult; 214556d637764b71563030c479bc35364a75188d559Ian Rogers { 215556d637764b71563030c479bc35364a75188d559Ian Rogers ScopedThreadStateChange tsc(self, kNative); 216556d637764b71563030c479bc35364a75188d559Ian Rogers jresult = fn(soa.Env(), rcvr.get(), arg0.get()); 217556d637764b71563030c479bc35364a75188d559Ian Rogers } 218ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier result->SetL(soa.Decode<mirror::Object>(jresult)); 21964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 22064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else if (shorty == "III") { 221460536209b741bc469f1b0857775449abb2102fbBernhard Rosenkränzer typedef jint (fntype)(JNIEnv*, jobject, jint, jint); 2222d7210188805292e463be4bcf7a133b654d7e0eaMathieu Chartier fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); 22364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedLocalRef<jobject> rcvr(soa.Env(), 22464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers soa.AddLocalReference<jobject>(receiver)); 22564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers ScopedThreadStateChange tsc(self, kNative); 2265d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao result->SetI(fn(soa.Env(), rcvr.get(), args[0], args[1])); 22764b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } else { 228709b070044354d9f47641f273edacaeeb0240ab7David Sehr LOG(FATAL) << "Do something with native method: " << method->PrettyMethod() 22964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers << " shorty: " << shorty; 23064b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } 23164b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers } 23264b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers} 23364b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers 2348ece050d85fc244c72610244e440b0e00aa618faSebastien Hertzenum InterpreterImplKind { 2351452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee kSwitchImplKind, // Switch-based interpreter implementation. 2361452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee kMterpImplKind // Assembly interpreter 2378ece050d85fc244c72610244e440b0e00aa618faSebastien Hertz}; 238fa46d3ee8cba2985c5c8bdfe47d15daf0613ebdcIan Rogers 2391452bee8f06b9f76a333ddf4760e4beaa82f8099buzbeestatic constexpr InterpreterImplKind kInterpreterImplKind = kMterpImplKind; 24000b53b7f3f9ce5996b767b52c28dd846f47a723cAlexey Frunze 2410122320f86ae004aa195d76814c52564d84ee632Aart Bikstatic inline JValue Execute( 2420122320f86ae004aa195d76814c52564d84ee632Aart Bik Thread* self, 243808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier const CodeItemDataAccessor& accessor, 2440122320f86ae004aa195d76814c52564d84ee632Aart Bik ShadowFrame& shadow_frame, 2450122320f86ae004aa195d76814c52564d84ee632Aart Bik JValue result_register, 246bdf7f1c3ab65ccb70f62db5ab31dba060632d458Andreas Gampe bool stay_in_interpreter = false) REQUIRES_SHARED(Locks::mutator_lock_) { 2471452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee DCHECK(!shadow_frame.GetMethod()->IsAbstract()); 248848871b4d8481229c32e0d048a9856e5a9a17ef9Ian Rogers DCHECK(!shadow_frame.GetMethod()->IsNative()); 249734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee if (LIKELY(shadow_frame.GetDexPC() == 0)) { // Entering the method, but not via deoptimization. 250734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee if (kIsDebugBuild) { 251734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee self->AssertNoPendingException(); 252734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee } 253734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation(); 254734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee ArtMethod *method = shadow_frame.GetMethod(); 255734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee 256734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee if (UNLIKELY(instrumentation->HasMethodEntryListeners())) { 257808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier instrumentation->MethodEnterEvent(self, 258808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier shadow_frame.GetThisObject(accessor.InsSize()), 259808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier method, 260808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier 0); 261b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light if (UNLIKELY(self->IsExceptionPending())) { 262b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light instrumentation->MethodUnwindEvent(self, 263808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier shadow_frame.GetThisObject(accessor.InsSize()), 264b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light method, 265b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light 0); 266b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light return JValue(); 267b7edcda968bb0cbaa69a3ad387fcd3194f5612beAlex Light } 268734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee } 269734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee 2700122320f86ae004aa195d76814c52564d84ee632Aart Bik if (!stay_in_interpreter) { 2710122320f86ae004aa195d76814c52564d84ee632Aart Bik jit::Jit* jit = Runtime::Current()->GetJit(); 2720122320f86ae004aa195d76814c52564d84ee632Aart Bik if (jit != nullptr) { 2730122320f86ae004aa195d76814c52564d84ee632Aart Bik jit->MethodEntered(self, shadow_frame.GetMethod()); 2740122320f86ae004aa195d76814c52564d84ee632Aart Bik if (jit->CanInvokeCompiledCode(method)) { 2750122320f86ae004aa195d76814c52564d84ee632Aart Bik JValue result; 276734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee 2770122320f86ae004aa195d76814c52564d84ee632Aart Bik // Pop the shadow frame before calling into compiled code. 2780122320f86ae004aa195d76814c52564d84ee632Aart Bik self->PopShadowFrame(); 2795ea8413714ceec50a758df6614dc4a3ec6179112Jeff Hao // Calculate the offset of the first input reg. The input registers are in the high regs. 2805ea8413714ceec50a758df6614dc4a3ec6179112Jeff Hao // It's ok to access the code item here since JIT code will have been touched by the 2815ea8413714ceec50a758df6614dc4a3ec6179112Jeff Hao // interpreter and compiler already. 282808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier uint16_t arg_offset = accessor.RegistersSize() - accessor.InsSize(); 2835ea8413714ceec50a758df6614dc4a3ec6179112Jeff Hao ArtInterpreterToCompiledCodeBridge(self, nullptr, &shadow_frame, arg_offset, &result); 2840122320f86ae004aa195d76814c52564d84ee632Aart Bik // Push the shadow frame back as the caller will expect it. 2850122320f86ae004aa195d76814c52564d84ee632Aart Bik self->PushShadowFrame(&shadow_frame); 286734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee 2870122320f86ae004aa195d76814c52564d84ee632Aart Bik return result; 2880122320f86ae004aa195d76814c52564d84ee632Aart Bik } 289274fe4adcb0610a9920be7814d9beb9cac6417ceNicolas Geoffray } 290734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee } 291734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee } 292734f3aa9f758236b6f1ace6347895af90b0d813dbuzbee 293580667b8d9cf6943596efff4df64f5879c1529e3Andreas Gampe ArtMethod* method = shadow_frame.GetMethod(); 294580667b8d9cf6943596efff4df64f5879c1529e3Andreas Gampe 295580667b8d9cf6943596efff4df64f5879c1529e3Andreas Gampe DCheckStaticState(self, method); 2968ece050d85fc244c72610244e440b0e00aa618faSebastien Hertz 29756fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe // Lock counting is a special version of accessibility checks, and for simplicity and 29856fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe // reduction of template parameters, we gate it behind access-checks mode. 29956fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe DCHECK(!method->SkipAccessChecks() || !method->MustCountLocks()); 30056fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe 301d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz bool transaction_active = Runtime::Current()->IsActiveTransaction(); 30256fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe if (LIKELY(method->SkipAccessChecks())) { 303233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz // Enter the "without access check" interpreter. 3041452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee if (kInterpreterImplKind == kMterpImplKind) { 305d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz if (transaction_active) { 3061452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee // No Mterp variant - just use the switch interpreter. 307808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<false, true>(self, accessor, shadow_frame, result_register, 3081452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 309fd522f9039befff986701ff05054ffdd1be1dd33Bill Buzbee } else if (UNLIKELY(!Runtime::Current()->IsStarted())) { 310808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<false, false>(self, accessor, shadow_frame, result_register, 311fd522f9039befff986701ff05054ffdd1be1dd33Bill Buzbee false); 312d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz } else { 3131452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee while (true) { 314fd522f9039befff986701ff05054ffdd1be1dd33Bill Buzbee // Mterp does not support all instrumentation/debugging. 3156740997e6934bbca27d5830a32352d82aabbd38bAndreas Gampe if (MterpShouldSwitchInterpreters() != 0) { 316808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<false, false>(self, accessor, shadow_frame, result_register, 3171452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 3181452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 319fc9555dac51a3cf12bb13f4e3781d2f2f6c9f91fMathieu Chartier bool returned = ExecuteMterpImpl(self, 320808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier accessor.Insns(), 321fc9555dac51a3cf12bb13f4e3781d2f2f6c9f91fMathieu Chartier &shadow_frame, 322fc9555dac51a3cf12bb13f4e3781d2f2f6c9f91fMathieu Chartier &result_register); 3231452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee if (returned) { 3241452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee return result_register; 3251452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } else { 3261452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee // Mterp didn't like that instruction. Single-step it with the reference interpreter. 327808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier result_register = ExecuteSwitchImpl<false, false>(self, accessor, shadow_frame, 328ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier result_register, true); 329e2abbc604ce003c776c00ecf1293796bb4c4ac5aAndreas Gampe if (shadow_frame.GetDexPC() == dex::kDexNoIndex) { 3301452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee // Single-stepped a return or an exception not handled locally. Return to caller. 331d6b48dbe715fbf1431394d2b6ef75cb19a4012ddbuzbee return result_register; 3321452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 3331452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 3341452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 3351452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 336f61df9b450f8734b84584671ad22fa4f29d386e4buzbee } else { 337f61df9b450f8734b84584671ad22fa4f29d386e4buzbee DCHECK_EQ(kInterpreterImplKind, kSwitchImplKind); 3381452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee if (transaction_active) { 339808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<false, true>(self, accessor, shadow_frame, result_register, 3401452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 3411452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } else { 342808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<false, false>(self, accessor, shadow_frame, result_register, 3431452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 344d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz } 3458ece050d85fc244c72610244e440b0e00aa618faSebastien Hertz } 346233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz } else { 347233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz // Enter the "with access check" interpreter. 3481452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee if (kInterpreterImplKind == kMterpImplKind) { 3491452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee // No access check variants for Mterp. Just use the switch version. 3501452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee if (transaction_active) { 351808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<true, true>(self, accessor, shadow_frame, result_register, 3521452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 3531452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } else { 354808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<true, false>(self, accessor, shadow_frame, result_register, 3551452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 3561452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee } 357f61df9b450f8734b84584671ad22fa4f29d386e4buzbee } else { 358f61df9b450f8734b84584671ad22fa4f29d386e4buzbee DCHECK_EQ(kInterpreterImplKind, kSwitchImplKind); 359d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz if (transaction_active) { 360808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<true, true>(self, accessor, shadow_frame, result_register, 3611452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 362d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz } else { 363808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return ExecuteSwitchImpl<true, false>(self, accessor, shadow_frame, result_register, 3641452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee false); 365d2fe10a3a34af171bf1631219cd2d6ff6b7778b5Sebastien Hertz } 3668ece050d85fc244c72610244e440b0e00aa618faSebastien Hertz } 367233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz } 368233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz} 369233ea8e084a95ad2a3af746dddbadb155db6a814Sebastien Hertz 370ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartiervoid EnterInterpreterFromInvoke(Thread* self, 371ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ArtMethod* method, 372ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ObjPtr<mirror::Object> receiver, 373ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier uint32_t* args, 374ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier JValue* result, 3750122320f86ae004aa195d76814c52564d84ee632Aart Bik bool stay_in_interpreter) { 37664b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers DCHECK_EQ(self, Thread::Current()); 377535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); 378535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { 379d752132c73072084a3def9257cca4fcee76047b6jeffhao ThrowStackOverflowError(self); 380d752132c73072084a3def9257cca4fcee76047b6jeffhao return; 381d752132c73072084a3def9257cca4fcee76047b6jeffhao } 382d752132c73072084a3def9257cca4fcee76047b6jeffhao 383db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light // This can happen if we are in forced interpreter mode and an obsolete method is called using 384db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light // reflection. 385db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light if (UNLIKELY(method->IsObsolete())) { 386db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light ThrowInternalError("Attempting to invoke obsolete version of '%s'.", 387db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light method->PrettyMethod().c_str()); 388db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light return; 389db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light } 390db01a091aefbd78b56777f4c2e8c5e3f2d8c2712Alex Light 391e861ebd5d9490cc86200f3859f3d36fadad4588cMathieu Chartier const char* old_cause = self->StartAssertNoThreadSuspension("EnterInterpreterFromInvoke"); 3920225f8e2939a9340cb7dcebfcfe7996a2bd9bce9David Sehr CodeItemDataAccessor accessor(method->DexInstructionData()); 3932fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers uint16_t num_regs; 3942fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers uint16_t num_ins; 395808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier if (accessor.HasCodeItem()) { 396808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier num_regs = accessor.RegistersSize(); 397808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier num_ins = accessor.InsSize(); 3989139e008abe30b7beaf4afd6533228a1dd9b202cAlex Light } else if (!method->IsInvokable()) { 399e861ebd5d9490cc86200f3859f3d36fadad4588cMathieu Chartier self->EndAssertNoThreadSuspension(old_cause); 4009139e008abe30b7beaf4afd6533228a1dd9b202cAlex Light method->ThrowInvocationTimeError(); 4010a9bb73c70298922ad33d67c209a4e440b216fa2jeffhao return; 4022fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } else { 4032fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers DCHECK(method->IsNative()); 404bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier num_regs = num_ins = ArtMethod::NumArgRegisters(method->GetShorty()); 4052fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers if (!method->IsStatic()) { 4062fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers num_regs++; 4072fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers num_ins++; 4082fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4092fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4102fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers // Set up shadow frame with matching number of reference slots to vregs. 4112fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers ShadowFrame* last_shadow_frame = self->GetManagedStack()->GetTopShadowFrame(); 412b30259251b22430fad12f1adeab671e4bf8f88f5Andreas Gampe ShadowFrameAllocaUniquePtr shadow_frame_unique_ptr = 41303ec930faded5bbfa096533ce60b6893847922dbAndreas Gampe CREATE_SHADOW_FRAME(num_regs, last_shadow_frame, method, /* dex pc */ 0); 414b30259251b22430fad12f1adeab671e4bf8f88f5Andreas Gampe ShadowFrame* shadow_frame = shadow_frame_unique_ptr.get(); 4156613519990bdb5616f2858c146f162ef760f03d2Jeff Hao self->PushShadowFrame(shadow_frame); 416e861ebd5d9490cc86200f3859f3d36fadad4588cMathieu Chartier 4172fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers size_t cur_reg = num_regs - num_ins; 4182fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers if (!method->IsStatic()) { 4192cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier CHECK(receiver != nullptr); 420ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier shadow_frame->SetVRegReference(cur_reg, receiver.Ptr()); 4212fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers ++cur_reg; 4222fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 423bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier uint32_t shorty_len = 0; 424bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier const char* shorty = method->GetShorty(&shorty_len); 4255d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao for (size_t shorty_pos = 0, arg_pos = 0; cur_reg < num_regs; ++shorty_pos, ++arg_pos, cur_reg++) { 426bfd9a4378eacaf2dc2bbe05ad48c5164fc93c9feMathieu Chartier DCHECK_LT(shorty_pos + 1, shorty_len); 4275d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao switch (shorty[shorty_pos + 1]) { 4282fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers case 'L': { 429ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ObjPtr<mirror::Object> o = 430ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier reinterpret_cast<StackReference<mirror::Object>*>(&args[arg_pos])->AsMirrorPtr(); 431ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier shadow_frame->SetVRegReference(cur_reg, o.Ptr()); 4322fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers break; 4332fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4345d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao case 'J': case 'D': { 4355d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao uint64_t wide_value = (static_cast<uint64_t>(args[arg_pos + 1]) << 32) | args[arg_pos]; 4365d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao shadow_frame->SetVRegLong(cur_reg, wide_value); 4372fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers cur_reg++; 4385d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao arg_pos++; 4392fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers break; 4405d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao } 4412fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers default: 4425d9173014c1ca09f7249a6b07629aa37778b5f8fJeff Hao shadow_frame->SetVReg(cur_reg, args[arg_pos]); 4432fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers break; 4442fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4452fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 44692246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier self->EndAssertNoThreadSuspension(old_cause); 44792246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier // Do this after populating the shadow frame in case EnsureInitialized causes a GC. 4486c5cb212fa7010ae7caf9dc765533aa967c95342Ian Rogers if (method->IsStatic() && UNLIKELY(!method->GetDeclaringClass()->IsInitialized())) { 44992246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 450eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier StackHandleScope<1> hs(self); 451eb8167a4f4d27fce0530f6724ab8032610cd146bMathieu Chartier Handle<mirror::Class> h_class(hs.NewHandle(method->GetDeclaringClass())); 4527b078e8c04f3e1451dbdd18543c8b9692b5b067eIan Rogers if (UNLIKELY(!class_linker->EnsureInitialized(self, h_class, true, true))) { 45392246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier CHECK(self->IsExceptionPending()); 45492246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier self->PopShadowFrame(); 45592246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier return; 45692246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier } 45792246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier } 45864b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers if (LIKELY(!method->IsNative())) { 459808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier JValue r = Execute(self, accessor, *shadow_frame, JValue(), stay_in_interpreter); 4602cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier if (result != nullptr) { 4616474d190d5604898354ebf767f1944b6e3e9b445Jeff Hao *result = r; 4622fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4632fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } else { 46464b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers // We don't expect to be asked to interpret native code (which is entered via a JNI compiler 46564b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers // generated stub) except during testing and image writing. 46692246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier // Update args to be the args in the shadow frame since the input ones could hold stale 46792246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier // references pointers due to moving GC. 46892246bb5d6caae4fdb09cd3c8c10d78e41932d45Mathieu Chartier args = shadow_frame->GetVRegArgs(method->IsStatic() ? 0 : 1); 46964b6d145fa53b8dfb07a8fc2426af13f155d5a4dIan Rogers if (!Runtime::Current()->IsStarted()) { 470ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier UnstartedRuntime::Jni(self, method, receiver.Ptr(), args, result); 4712fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } else { 4726474d190d5604898354ebf767f1944b6e3e9b445Jeff Hao InterpreterJni(self, method, shorty, receiver, args, result); 4732fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4742fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers } 4752fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers self->PopShadowFrame(); 4762fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers} 4772fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers 478ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yangstatic int16_t GetReceiverRegisterForStringInit(const Instruction* instr) { 479ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang DCHECK(instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE || 480ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang instr->Opcode() == Instruction::INVOKE_DIRECT); 481ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang return (instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE) ? 482ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang instr->VRegC_3rc() : instr->VRegC_35c(); 483ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang} 484ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang 48573be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffrayvoid EnterInterpreterFromDeoptimize(Thread* self, 48673be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray ShadowFrame* shadow_frame, 4872ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang JValue* ret_val, 48873be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray bool from_code, 4892ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DeoptimizationMethodType deopt_method_type) 490bdf7f1c3ab65ccb70f62db5ab31dba060632d458Andreas Gampe REQUIRES_SHARED(Locks::mutator_lock_) { 49111ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao JValue value; 4922cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier // Set value to last known result in case the shadow frame chain is empty. 4932cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier value.SetJ(ret_val->GetJ()); 494520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz // Are we executing the first shadow frame? 495520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz bool first = true; 4962cebb24bfc3247d3e9be138a3350106737455918Mathieu Chartier while (shadow_frame != nullptr) { 49756fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe // We do not want to recover lock state for lock counting when deoptimizing. Currently, 49856fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe // the compiler should not have compiled a method that failed structured-locking checks. 49956fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe DCHECK(!shadow_frame->GetMethod()->MustCountLocks()); 50056fdd0e63812764bbeb8cc52e376d3fd1f270052Andreas Gampe 50162d6c772205b8859f0ebf7ad105402ec4c3e2e01Ian Rogers self->SetTopOfShadowStack(shadow_frame); 5020225f8e2939a9340cb7dcebfcfe7996a2bd9bce9David Sehr CodeItemDataAccessor accessor(shadow_frame->GetMethod()->DexInstructionData()); 503270a0e16c3b8e5b95cbfdbd8996ac137c7c6322bSebastien Hertz const uint32_t dex_pc = shadow_frame->GetDexPC(); 50473be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray uint32_t new_dex_pc = dex_pc; 505270a0e16c3b8e5b95cbfdbd8996ac137c7c6322bSebastien Hertz if (UNLIKELY(self->IsExceptionPending())) { 506520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz // If we deoptimize from the QuickExceptionHandler, we already reported the exception to 507520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz // the instrumentation. To prevent from reporting it a second time, we simply pass a 508520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz // null Instrumentation*. 509270a0e16c3b8e5b95cbfdbd8996ac137c7c6322bSebastien Hertz const instrumentation::Instrumentation* const instrumentation = 510520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz first ? nullptr : Runtime::Current()->GetInstrumentation(); 5119fb1ab1f6bb58bdaccef78bc81b3202d0121e2edAlex Light new_dex_pc = MoveToExceptionHandler( 512e2abbc604ce003c776c00ecf1293796bb4c4ac5aAndreas Gampe self, *shadow_frame, instrumentation) ? shadow_frame->GetDexPC() : dex::kDexNoIndex; 51373be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray } else if (!from_code) { 5142ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // Deoptimization is not called from code directly. 515808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier const Instruction* instr = &accessor.InstructionAt(dex_pc); 5162ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang if (deopt_method_type == DeoptimizationMethodType::kKeepDexPc) { 5172ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(first); 5182ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // Need to re-execute the dex instruction. 5192ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // (1) An invocation might be split into class initialization and invoke. 5202ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // In this case, the invoke should not be skipped. 5212ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // (2) A suspend check should also execute the dex instruction at the 5222ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // corresponding dex pc. 5232ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK_EQ(new_dex_pc, dex_pc); 5242ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang } else if (instr->Opcode() == Instruction::MONITOR_ENTER || 5252ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang instr->Opcode() == Instruction::MONITOR_EXIT) { 5262ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(deopt_method_type == DeoptimizationMethodType::kDefault); 5272ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(first); 5282ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // Non-idempotent dex instruction should not be re-executed. 5292ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // On the other hand, if a MONITOR_ENTER is at the dex_pc of a suspend 5302ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // check, that MONITOR_ENTER should be executed. That case is handled 5312ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // above. 5322ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang new_dex_pc = dex_pc + instr->SizeInCodeUnits(); 5332ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang } else if (instr->IsInvoke()) { 5342ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(deopt_method_type == DeoptimizationMethodType::kDefault); 535ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang if (IsStringInit(instr, shadow_frame->GetMethod())) { 536ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang uint16_t this_obj_vreg = GetReceiverRegisterForStringInit(instr); 537ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang // Move the StringFactory.newStringFromChars() result into the register representing 538ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang // "this object" when invoking the string constructor in the original dex instruction. 539ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang // Also move the result into all aliases. 540ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang DCHECK(value.GetL()->IsString()); 541ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang SetStringInitValueToAllAliases(shadow_frame, this_obj_vreg, value); 542ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang // Calling string constructor in the original dex code doesn't generate a result value. 543ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang value.SetJ(0); 544ffedec510c07cf0f77d0cce51940838f2e630514Mingyao Yang } 545504a69081f63818ca332ddaf54e8198448554538Mingyao Yang new_dex_pc = dex_pc + instr->SizeInCodeUnits(); 546504a69081f63818ca332ddaf54e8198448554538Mingyao Yang } else if (instr->Opcode() == Instruction::NEW_INSTANCE) { 5472ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // A NEW_INSTANCE is simply re-executed, including 5482ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // "new-instance String" which is compiled into a call into 5492ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // StringFactory.newEmptyString(). 5502ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK_EQ(new_dex_pc, dex_pc); 551504a69081f63818ca332ddaf54e8198448554538Mingyao Yang } else { 5522ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(deopt_method_type == DeoptimizationMethodType::kDefault); 5532ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(first); 5542ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // By default, we re-execute the dex instruction since if they are not 5552ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // an invoke, so that we don't have to decode the dex instruction to move 5562ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // result into the right vreg. All slow paths have been audited to be 5572ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // idempotent except monitor-enter/exit and invocation stubs. 5582ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // TODO: move result and advance dex pc. That also requires that we 5592ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // can tell the return type of a runtime method, possibly by decoding 5602ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // the dex instruction at the caller. 5612ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK_EQ(new_dex_pc, dex_pc); 562504a69081f63818ca332ddaf54e8198448554538Mingyao Yang } 56373be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray } else { 56473be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray // Nothing to do, the dex_pc is the one at which the code requested 56573be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray // the deoptimization. 5662ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK(first); 5672ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang DCHECK_EQ(new_dex_pc, dex_pc); 568270a0e16c3b8e5b95cbfdbd8996ac137c7c6322bSebastien Hertz } 569e2abbc604ce003c776c00ecf1293796bb4c4ac5aAndreas Gampe if (new_dex_pc != dex::kDexNoIndex) { 570959742483885779f106e000df6dd422fc8657931Nicolas Geoffray shadow_frame->SetDexPC(new_dex_pc); 571808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier value = Execute(self, accessor, *shadow_frame, value); 572270a0e16c3b8e5b95cbfdbd8996ac137c7c6322bSebastien Hertz } 57311ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao ShadowFrame* old_frame = shadow_frame; 57411ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao shadow_frame = shadow_frame->GetLink(); 575241a9588c6d7d0fcb4c92da40c7141863930083aChristopher Ferris ShadowFrame::DeleteDeoptimizedFrame(old_frame); 5762ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // Following deoptimizations of shadow frames must be at invocation point 5772ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang // and should advance dex pc past the invoke instruction. 57873be1e8f8609708f6624bb297c9628de44fd8b6fNicolas Geoffray from_code = false; 5792ee17909eadd7155f4a7751c38398b36fc267f04Mingyao Yang deopt_method_type = DeoptimizationMethodType::kDefault; 580520633bebd2bf4d70884d30f179dbde9f275aac6Sebastien Hertz first = false; 58111ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao } 58211ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao ret_val->SetJ(value.GetJ()); 58311ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao} 58411ffc2d02b7d979f26a8a04013fce3eb4f9a2816Jeff Hao 585808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu ChartierJValue EnterInterpreterFromEntryPoint(Thread* self, const CodeItemDataAccessor& accessor, 5866f3dbbadf4ce66982eb3d400e0a74cb73eb034f3Ian Rogers ShadowFrame* shadow_frame) { 587f3e9855ee2000106b54fd479f7a46da2dc2ad079Ian Rogers DCHECK_EQ(self, Thread::Current()); 588535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); 589535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { 590f3e9855ee2000106b54fd479f7a46da2dc2ad079Ian Rogers ThrowStackOverflowError(self); 591f3e9855ee2000106b54fd479f7a46da2dc2ad079Ian Rogers return JValue(); 592f3e9855ee2000106b54fd479f7a46da2dc2ad079Ian Rogers } 593f3e9855ee2000106b54fd479f7a46da2dc2ad079Ian Rogers 59471cd50fb67fa48667b0ab59aa436a582c04ba43dNicolas Geoffray jit::Jit* jit = Runtime::Current()->GetJit(); 59571cd50fb67fa48667b0ab59aa436a582c04ba43dNicolas Geoffray if (jit != nullptr) { 59671cd50fb67fa48667b0ab59aa436a582c04ba43dNicolas Geoffray jit->NotifyCompiledCodeToInterpreterTransition(self, shadow_frame->GetMethod()); 59771cd50fb67fa48667b0ab59aa436a582c04ba43dNicolas Geoffray } 598808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier return Execute(self, accessor, *shadow_frame, JValue()); 5997db619bb2a4e01e8532a04b613745d4926b205d7Ian Rogers} 6007db619bb2a4e01e8532a04b613745d4926b205d7Ian Rogers 601ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartiervoid ArtInterpreterToInterpreterBridge(Thread* self, 602808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier const CodeItemDataAccessor& accessor, 603ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ShadowFrame* shadow_frame, 604ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier JValue* result) { 605535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); 606535a3fbc08e1577f43aec7402cab80c14ca64c41Nicolas Geoffray if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { 607167436311a08a65dea28dda079a137893821c9c7Jeff Hao ThrowStackOverflowError(self); 6086951067ee14754454e17221fdef0d3d5ed7c4f7eJeff Hao return; 609167436311a08a65dea28dda079a137893821c9c7Jeff Hao } 610167436311a08a65dea28dda079a137893821c9c7Jeff Hao 611e861ebd5d9490cc86200f3859f3d36fadad4588cMathieu Chartier self->PushShadowFrame(shadow_frame); 612eb7c144a6aff7da673ba53d501c46f00311d4d7fAlex Light ArtMethod* method = shadow_frame->GetMethod(); 613c61124bdeaae94f977ffc36ac69535e792c226f2Sebastien Hertz // Ensure static methods are initialized. 614eb7c144a6aff7da673ba53d501c46f00311d4d7fAlex Light const bool is_static = method->IsStatic(); 615e94652f1e321b2c8b71acbe5b07d2ebf69fbdb99Ian Rogers if (is_static) { 616ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ObjPtr<mirror::Class> declaring_class = method->GetDeclaringClass(); 6176c5cb212fa7010ae7caf9dc765533aa967c95342Ian Rogers if (UNLIKELY(!declaring_class->IsInitialized())) { 6180cd81352a7c06e381951cea1b104fd73516f4341Mathieu Chartier StackHandleScope<1> hs(self); 619ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier HandleWrapperObjPtr<mirror::Class> h_declaring_class(hs.NewHandleWrapper(&declaring_class)); 6200cd81352a7c06e381951cea1b104fd73516f4341Mathieu Chartier if (UNLIKELY(!Runtime::Current()->GetClassLinker()->EnsureInitialized( 6217b078e8c04f3e1451dbdd18543c8b9692b5b067eIan Rogers self, h_declaring_class, true, true))) { 6220cd81352a7c06e381951cea1b104fd73516f4341Mathieu Chartier DCHECK(self->IsExceptionPending()); 623e861ebd5d9490cc86200f3859f3d36fadad4588cMathieu Chartier self->PopShadowFrame(); 624c61124bdeaae94f977ffc36ac69535e792c226f2Sebastien Hertz return; 625c61124bdeaae94f977ffc36ac69535e792c226f2Sebastien Hertz } 6260cd81352a7c06e381951cea1b104fd73516f4341Mathieu Chartier CHECK(h_declaring_class->IsInitializing()); 627167436311a08a65dea28dda079a137893821c9c7Jeff Hao } 628167436311a08a65dea28dda079a137893821c9c7Jeff Hao } 629167436311a08a65dea28dda079a137893821c9c7Jeff Hao 630e94652f1e321b2c8b71acbe5b07d2ebf69fbdb99Ian Rogers if (LIKELY(!shadow_frame->GetMethod()->IsNative())) { 631808c7a57bb913b13c22884f57cdacd59bf1fdb3fMathieu Chartier result->SetJ(Execute(self, accessor, *shadow_frame, JValue()).GetJ()); 632167436311a08a65dea28dda079a137893821c9c7Jeff Hao } else { 633167436311a08a65dea28dda079a137893821c9c7Jeff Hao // We don't expect to be asked to interpret native code (which is entered via a JNI compiler 634167436311a08a65dea28dda079a137893821c9c7Jeff Hao // generated stub) except during testing and image writing. 635167436311a08a65dea28dda079a137893821c9c7Jeff Hao CHECK(!Runtime::Current()->IsStarted()); 636ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier ObjPtr<mirror::Object> receiver = is_static ? nullptr : shadow_frame->GetVRegReference(0); 637e94652f1e321b2c8b71acbe5b07d2ebf69fbdb99Ian Rogers uint32_t* args = shadow_frame->GetVRegArgs(is_static ? 0 : 1); 638ef41db7a3f322a1feb305fdb457410c4cea94d00Mathieu Chartier UnstartedRuntime::Jni(self, shadow_frame->GetMethod(), receiver.Ptr(), args, result); 639167436311a08a65dea28dda079a137893821c9c7Jeff Hao } 640167436311a08a65dea28dda079a137893821c9c7Jeff Hao 641167436311a08a65dea28dda079a137893821c9c7Jeff Hao self->PopShadowFrame(); 642167436311a08a65dea28dda079a137893821c9c7Jeff Hao} 643167436311a08a65dea28dda079a137893821c9c7Jeff Hao 6441452bee8f06b9f76a333ddf4760e4beaa82f8099buzbeevoid CheckInterpreterAsmConstants() { 6451452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee CheckMterpAsmConstants(); 6461452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee} 6471452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee 6481452bee8f06b9f76a333ddf4760e4beaa82f8099buzbeevoid InitInterpreterTls(Thread* self) { 6491452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee InitMterpTls(self); 6501452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee} 6511452bee8f06b9f76a333ddf4760e4beaa82f8099buzbee 6522fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers} // namespace interpreter 6532fa6b2e2fc3d2a2fc27808ce518dc76b80ce369aIan Rogers} // namespace art 654