Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 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 | |
Andreas Gampe | 3cfa4d0 | 2015-10-06 17:04:01 -0700 | [diff] [blame] | 17 | #include "interpreter.h" |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 18 | |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 19 | #include <limits> |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 20 | |
Andreas Gampe | 103992b | 2016-01-04 15:32:43 -0800 | [diff] [blame] | 21 | #include "common_throws.h" |
Andreas Gampe | 3cfa4d0 | 2015-10-06 17:04:01 -0700 | [diff] [blame] | 22 | #include "interpreter_common.h" |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 23 | #include "mirror/string-inl.h" |
Andreas Gampe | 2969bcd | 2015-03-09 12:57:41 -0700 | [diff] [blame] | 24 | #include "scoped_thread_state_change.h" |
| 25 | #include "ScopedLocalRef.h" |
Andreas Gampe | b302592 | 2015-09-01 14:45:00 -0700 | [diff] [blame] | 26 | #include "stack.h" |
Andreas Gampe | 2969bcd | 2015-03-09 12:57:41 -0700 | [diff] [blame] | 27 | #include "unstarted_runtime.h" |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 28 | #include "mterp/mterp.h" |
buzbee | 734f3aa | 2016-01-28 14:20:06 -0800 | [diff] [blame] | 29 | #include "jit/jit.h" |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 30 | |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 31 | namespace art { |
| 32 | namespace interpreter { |
| 33 | |
Ian Rogers | fc0e94b | 2013-09-23 23:51:32 -0700 | [diff] [blame] | 34 | static void InterpreterJni(Thread* self, ArtMethod* method, const StringPiece& shorty, |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 35 | Object* receiver, uint32_t* args, JValue* result) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 36 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 37 | // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler, |
| 38 | // it should be removed and JNI compiled stubs used instead. |
| 39 | ScopedObjectAccessUnchecked soa(self); |
| 40 | if (method->IsStatic()) { |
| 41 | if (shorty == "L") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 42 | typedef jobject (fntype)(JNIEnv*, jclass); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 43 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 44 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 45 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
Ian Rogers | 556d637 | 2012-11-20 12:19:36 -0800 | [diff] [blame] | 46 | jobject jresult; |
| 47 | { |
| 48 | ScopedThreadStateChange tsc(self, kNative); |
| 49 | jresult = fn(soa.Env(), klass.get()); |
| 50 | } |
| 51 | result->SetL(soa.Decode<Object*>(jresult)); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 52 | } else if (shorty == "V") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 53 | typedef void (fntype)(JNIEnv*, jclass); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 54 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 55 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 56 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 57 | ScopedThreadStateChange tsc(self, kNative); |
| 58 | fn(soa.Env(), klass.get()); |
| 59 | } else if (shorty == "Z") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 60 | typedef jboolean (fntype)(JNIEnv*, jclass); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 61 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 62 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 63 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 64 | ScopedThreadStateChange tsc(self, kNative); |
| 65 | result->SetZ(fn(soa.Env(), klass.get())); |
| 66 | } else if (shorty == "BI") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 67 | typedef jbyte (fntype)(JNIEnv*, jclass, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 68 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 69 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 70 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 71 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 72 | result->SetB(fn(soa.Env(), klass.get(), args[0])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 73 | } else if (shorty == "II") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 74 | typedef jint (fntype)(JNIEnv*, jclass, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 75 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 76 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 77 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 78 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 79 | result->SetI(fn(soa.Env(), klass.get(), args[0])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 80 | } else if (shorty == "LL") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 81 | typedef jobject (fntype)(JNIEnv*, jclass, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 82 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 83 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 84 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 85 | ScopedLocalRef<jobject> arg0(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 86 | soa.AddLocalReference<jobject>( |
| 87 | reinterpret_cast<Object*>(args[0]))); |
Ian Rogers | 556d637 | 2012-11-20 12:19:36 -0800 | [diff] [blame] | 88 | jobject jresult; |
| 89 | { |
| 90 | ScopedThreadStateChange tsc(self, kNative); |
| 91 | jresult = fn(soa.Env(), klass.get(), arg0.get()); |
| 92 | } |
| 93 | result->SetL(soa.Decode<Object*>(jresult)); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 94 | } else if (shorty == "IIZ") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 95 | typedef jint (fntype)(JNIEnv*, jclass, jint, jboolean); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 96 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 97 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 98 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 99 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 100 | result->SetI(fn(soa.Env(), klass.get(), args[0], args[1])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 101 | } else if (shorty == "ILI") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 102 | typedef jint (fntype)(JNIEnv*, jclass, jobject, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 103 | fntype* const fn = reinterpret_cast<fntype*>(const_cast<void*>( |
| 104 | method->GetEntryPointFromJni())); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 105 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 106 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 107 | ScopedLocalRef<jobject> arg0(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 108 | soa.AddLocalReference<jobject>( |
| 109 | reinterpret_cast<Object*>(args[0]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 110 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 111 | result->SetI(fn(soa.Env(), klass.get(), arg0.get(), args[1])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 112 | } else if (shorty == "SIZ") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 113 | typedef jshort (fntype)(JNIEnv*, jclass, jint, jboolean); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 114 | fntype* const fn = |
| 115 | reinterpret_cast<fntype*>(const_cast<void*>(method->GetEntryPointFromJni())); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 116 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 117 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 118 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 119 | result->SetS(fn(soa.Env(), klass.get(), args[0], args[1])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 120 | } else if (shorty == "VIZ") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 121 | typedef void (fntype)(JNIEnv*, jclass, jint, jboolean); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 122 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 123 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 124 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 125 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 126 | fn(soa.Env(), klass.get(), args[0], args[1]); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 127 | } else if (shorty == "ZLL") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 128 | typedef jboolean (fntype)(JNIEnv*, jclass, jobject, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 129 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 130 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 131 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 132 | ScopedLocalRef<jobject> arg0(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 133 | soa.AddLocalReference<jobject>( |
| 134 | reinterpret_cast<Object*>(args[0]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 135 | ScopedLocalRef<jobject> arg1(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 136 | soa.AddLocalReference<jobject>( |
| 137 | reinterpret_cast<Object*>(args[1]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 138 | ScopedThreadStateChange tsc(self, kNative); |
| 139 | result->SetZ(fn(soa.Env(), klass.get(), arg0.get(), arg1.get())); |
| 140 | } else if (shorty == "ZILL") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 141 | typedef jboolean (fntype)(JNIEnv*, jclass, jint, jobject, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 142 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 143 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 144 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 145 | ScopedLocalRef<jobject> arg1(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 146 | soa.AddLocalReference<jobject>( |
| 147 | reinterpret_cast<Object*>(args[1]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 148 | ScopedLocalRef<jobject> arg2(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 149 | soa.AddLocalReference<jobject>( |
| 150 | reinterpret_cast<Object*>(args[2]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 151 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 152 | result->SetZ(fn(soa.Env(), klass.get(), args[0], arg1.get(), arg2.get())); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 153 | } else if (shorty == "VILII") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 154 | typedef void (fntype)(JNIEnv*, jclass, jint, jobject, jint, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 155 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 156 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 157 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 158 | ScopedLocalRef<jobject> arg1(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 159 | soa.AddLocalReference<jobject>( |
| 160 | reinterpret_cast<Object*>(args[1]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 161 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 162 | fn(soa.Env(), klass.get(), args[0], arg1.get(), args[2], args[3]); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 163 | } else if (shorty == "VLILII") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 164 | typedef void (fntype)(JNIEnv*, jclass, jobject, jint, jobject, jint, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 165 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 166 | ScopedLocalRef<jclass> klass(soa.Env(), |
| 167 | soa.AddLocalReference<jclass>(method->GetDeclaringClass())); |
| 168 | ScopedLocalRef<jobject> arg0(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 169 | soa.AddLocalReference<jobject>( |
| 170 | reinterpret_cast<Object*>(args[0]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 171 | ScopedLocalRef<jobject> arg2(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 172 | soa.AddLocalReference<jobject>( |
| 173 | reinterpret_cast<Object*>(args[2]))); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 174 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 175 | fn(soa.Env(), klass.get(), arg0.get(), args[1], arg2.get(), args[3], args[4]); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 176 | } else { |
| 177 | LOG(FATAL) << "Do something with static native method: " << PrettyMethod(method) |
| 178 | << " shorty: " << shorty; |
| 179 | } |
| 180 | } else { |
| 181 | if (shorty == "L") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 182 | typedef jobject (fntype)(JNIEnv*, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 183 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 184 | ScopedLocalRef<jobject> rcvr(soa.Env(), |
| 185 | soa.AddLocalReference<jobject>(receiver)); |
Ian Rogers | 556d637 | 2012-11-20 12:19:36 -0800 | [diff] [blame] | 186 | jobject jresult; |
| 187 | { |
| 188 | ScopedThreadStateChange tsc(self, kNative); |
| 189 | jresult = fn(soa.Env(), rcvr.get()); |
| 190 | } |
| 191 | result->SetL(soa.Decode<Object*>(jresult)); |
Jeff Hao | 3dd9f76 | 2013-07-08 13:09:25 -0700 | [diff] [blame] | 192 | } else if (shorty == "V") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 193 | typedef void (fntype)(JNIEnv*, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 194 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Jeff Hao | 3dd9f76 | 2013-07-08 13:09:25 -0700 | [diff] [blame] | 195 | ScopedLocalRef<jobject> rcvr(soa.Env(), |
| 196 | soa.AddLocalReference<jobject>(receiver)); |
| 197 | ScopedThreadStateChange tsc(self, kNative); |
| 198 | fn(soa.Env(), rcvr.get()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 199 | } else if (shorty == "LL") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 200 | typedef jobject (fntype)(JNIEnv*, jobject, jobject); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 201 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 202 | ScopedLocalRef<jobject> rcvr(soa.Env(), |
| 203 | soa.AddLocalReference<jobject>(receiver)); |
| 204 | ScopedLocalRef<jobject> arg0(soa.Env(), |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 205 | soa.AddLocalReference<jobject>( |
| 206 | reinterpret_cast<Object*>(args[0]))); |
Ian Rogers | 556d637 | 2012-11-20 12:19:36 -0800 | [diff] [blame] | 207 | jobject jresult; |
| 208 | { |
| 209 | ScopedThreadStateChange tsc(self, kNative); |
| 210 | jresult = fn(soa.Env(), rcvr.get(), arg0.get()); |
Ian Rogers | 556d637 | 2012-11-20 12:19:36 -0800 | [diff] [blame] | 211 | } |
| 212 | result->SetL(soa.Decode<Object*>(jresult)); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 213 | ScopedThreadStateChange tsc(self, kNative); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 214 | } else if (shorty == "III") { |
Bernhard Rosenkränzer | 4605362 | 2013-12-12 02:15:52 +0100 | [diff] [blame] | 215 | typedef jint (fntype)(JNIEnv*, jobject, jint, jint); |
Mathieu Chartier | 2d72101 | 2014-11-10 11:08:06 -0800 | [diff] [blame] | 216 | fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni()); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 217 | ScopedLocalRef<jobject> rcvr(soa.Env(), |
| 218 | soa.AddLocalReference<jobject>(receiver)); |
| 219 | ScopedThreadStateChange tsc(self, kNative); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 220 | result->SetI(fn(soa.Env(), rcvr.get(), args[0], args[1])); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 221 | } else { |
| 222 | LOG(FATAL) << "Do something with native method: " << PrettyMethod(method) |
| 223 | << " shorty: " << shorty; |
| 224 | } |
| 225 | } |
| 226 | } |
| 227 | |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 228 | enum InterpreterImplKind { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 229 | kSwitchImplKind, // Switch-based interpreter implementation. |
| 230 | kComputedGotoImplKind, // Computed-goto-based interpreter implementation. |
| 231 | kMterpImplKind // Assembly interpreter |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 232 | }; |
Andreas Gampe | 277ccbd | 2014-11-03 21:36:10 -0800 | [diff] [blame] | 233 | static std::ostream& operator<<(std::ostream& os, const InterpreterImplKind& rhs) { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 234 | os << ((rhs == kSwitchImplKind) |
| 235 | ? "Switch-based interpreter" |
| 236 | : (rhs == kComputedGotoImplKind) |
| 237 | ? "Computed-goto-based interpreter" |
| 238 | : "Asm interpreter"); |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 239 | return os; |
| 240 | } |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 241 | |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 242 | #if !defined(__clang__) |
Bill Buzbee | 7c58bd4 | 2016-01-20 20:46:01 +0000 | [diff] [blame] | 243 | #if (defined(__arm__) || defined(__i386__)) |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 244 | // TODO: remove when all targets implemented. |
| 245 | static constexpr InterpreterImplKind kInterpreterImplKind = kMterpImplKind; |
| 246 | #else |
Ian Rogers | b48b9eb | 2014-02-28 16:20:21 -0800 | [diff] [blame] | 247 | static constexpr InterpreterImplKind kInterpreterImplKind = kComputedGotoImplKind; |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 248 | #endif |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 249 | #else |
| 250 | // Clang 3.4 fails to build the goto interpreter implementation. |
Bill Buzbee | 7c58bd4 | 2016-01-20 20:46:01 +0000 | [diff] [blame] | 251 | #if (defined(__arm__) || defined(__i386__)) |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 252 | static constexpr InterpreterImplKind kInterpreterImplKind = kMterpImplKind; |
| 253 | #else |
| 254 | static constexpr InterpreterImplKind kInterpreterImplKind = kSwitchImplKind; |
| 255 | #endif |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 256 | template<bool do_access_check, bool transaction_active> |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 257 | JValue ExecuteGotoImpl(Thread*, const DexFile::CodeItem*, ShadowFrame&, JValue) { |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 258 | LOG(FATAL) << "UNREACHABLE"; |
Ian Rogers | 2c4257b | 2014-10-24 14:20:06 -0700 | [diff] [blame] | 259 | UNREACHABLE(); |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 260 | } |
| 261 | // Explicit definitions of ExecuteGotoImpl. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 262 | template<> SHARED_REQUIRES(Locks::mutator_lock_) |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 263 | JValue ExecuteGotoImpl<true, false>(Thread* self, const DexFile::CodeItem* code_item, |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 264 | ShadowFrame& shadow_frame, JValue result_register); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 265 | template<> SHARED_REQUIRES(Locks::mutator_lock_) |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 266 | JValue ExecuteGotoImpl<false, false>(Thread* self, const DexFile::CodeItem* code_item, |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 267 | ShadowFrame& shadow_frame, JValue result_register); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 268 | template<> SHARED_REQUIRES(Locks::mutator_lock_) |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 269 | JValue ExecuteGotoImpl<true, true>(Thread* self, const DexFile::CodeItem* code_item, |
| 270 | ShadowFrame& shadow_frame, JValue result_register); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 271 | template<> SHARED_REQUIRES(Locks::mutator_lock_) |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 272 | JValue ExecuteGotoImpl<false, true>(Thread* self, const DexFile::CodeItem* code_item, |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 273 | ShadowFrame& shadow_frame, JValue result_register); |
Sebastien Hertz | fa888d0 | 2014-09-30 12:00:11 +0200 | [diff] [blame] | 274 | #endif |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 275 | |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 276 | static JValue Execute(Thread* self, const DexFile::CodeItem* code_item, ShadowFrame& shadow_frame, |
| 277 | JValue result_register) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 278 | SHARED_REQUIRES(Locks::mutator_lock_); |
Sebastien Hertz | 233ea8e | 2013-06-06 11:57:09 +0200 | [diff] [blame] | 279 | |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 280 | static inline JValue Execute(Thread* self, const DexFile::CodeItem* code_item, |
Sebastien Hertz | 233ea8e | 2013-06-06 11:57:09 +0200 | [diff] [blame] | 281 | ShadowFrame& shadow_frame, JValue result_register) { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 282 | DCHECK(!shadow_frame.GetMethod()->IsAbstract()); |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 283 | DCHECK(!shadow_frame.GetMethod()->IsNative()); |
buzbee | 734f3aa | 2016-01-28 14:20:06 -0800 | [diff] [blame] | 284 | if (LIKELY(shadow_frame.GetDexPC() == 0)) { // Entering the method, but not via deoptimization. |
| 285 | if (kIsDebugBuild) { |
| 286 | self->AssertNoPendingException(); |
| 287 | } |
| 288 | instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation(); |
| 289 | ArtMethod *method = shadow_frame.GetMethod(); |
| 290 | |
| 291 | if (UNLIKELY(instrumentation->HasMethodEntryListeners())) { |
| 292 | instrumentation->MethodEnterEvent(self, shadow_frame.GetThisObject(code_item->ins_size_), |
| 293 | method, 0); |
| 294 | } |
| 295 | |
| 296 | if (UNLIKELY(Runtime::Current()->GetJit() != nullptr && |
| 297 | Runtime::Current()->GetJit()->JitAtFirstUse() && |
| 298 | method->HasAnyCompiledCode())) { |
| 299 | JValue result; |
| 300 | |
| 301 | // Pop the shadow frame before calling into compiled code. |
| 302 | self->PopShadowFrame(); |
| 303 | ArtInterpreterToCompiledCodeBridge(self, code_item, &shadow_frame, &result); |
| 304 | // Push the shadow frame back as the caller will expect it. |
| 305 | self->PushShadowFrame(&shadow_frame); |
| 306 | |
| 307 | return result; |
| 308 | } |
| 309 | } |
| 310 | |
Sebastien Hertz | 4e99b3d | 2014-06-24 14:35:40 +0200 | [diff] [blame] | 311 | shadow_frame.GetMethod()->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self); |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 312 | |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 313 | bool transaction_active = Runtime::Current()->IsActiveTransaction(); |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 314 | if (LIKELY(shadow_frame.GetMethod()->IsPreverified())) { |
Sebastien Hertz | 233ea8e | 2013-06-06 11:57:09 +0200 | [diff] [blame] | 315 | // Enter the "without access check" interpreter. |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 316 | if (kInterpreterImplKind == kMterpImplKind) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 317 | if (transaction_active) { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 318 | // No Mterp variant - just use the switch interpreter. |
| 319 | return ExecuteSwitchImpl<false, true>(self, code_item, shadow_frame, result_register, |
| 320 | false); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 321 | } else { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 322 | const instrumentation::Instrumentation* const instrumentation = |
| 323 | Runtime::Current()->GetInstrumentation(); |
| 324 | while (true) { |
buzbee | 64320f9 | 2016-01-12 12:45:51 -0800 | [diff] [blame] | 325 | if (instrumentation->IsActive() || !Runtime::Current()->IsStarted()) { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 326 | // TODO: allow JIT profiling instrumentation. Now, just punt on all instrumentation. |
| 327 | #if !defined(__clang__) |
| 328 | return ExecuteGotoImpl<false, false>(self, code_item, shadow_frame, result_register); |
| 329 | #else |
| 330 | return ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, result_register, |
| 331 | false); |
| 332 | #endif |
| 333 | } |
| 334 | bool returned = ExecuteMterpImpl(self, code_item, &shadow_frame, &result_register); |
| 335 | if (returned) { |
| 336 | return result_register; |
| 337 | } else { |
| 338 | // Mterp didn't like that instruction. Single-step it with the reference interpreter. |
buzbee | d6b48db | 2016-01-28 15:48:55 -0800 | [diff] [blame^] | 339 | result_register = ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 340 | result_register, true); |
| 341 | if (shadow_frame.GetDexPC() == DexFile::kDexNoIndex) { |
| 342 | // Single-stepped a return or an exception not handled locally. Return to caller. |
buzbee | d6b48db | 2016-01-28 15:48:55 -0800 | [diff] [blame^] | 343 | return result_register; |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 344 | } |
| 345 | } |
| 346 | } |
| 347 | } |
| 348 | } else if (kInterpreterImplKind == kSwitchImplKind) { |
| 349 | if (transaction_active) { |
| 350 | return ExecuteSwitchImpl<false, true>(self, code_item, shadow_frame, result_register, |
| 351 | false); |
| 352 | } else { |
| 353 | return ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, result_register, |
| 354 | false); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 355 | } |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 356 | } else { |
| 357 | DCHECK_EQ(kInterpreterImplKind, kComputedGotoImplKind); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 358 | if (transaction_active) { |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 359 | return ExecuteGotoImpl<false, true>(self, code_item, shadow_frame, result_register); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 360 | } else { |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 361 | return ExecuteGotoImpl<false, false>(self, code_item, shadow_frame, result_register); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 362 | } |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 363 | } |
Sebastien Hertz | 233ea8e | 2013-06-06 11:57:09 +0200 | [diff] [blame] | 364 | } else { |
| 365 | // Enter the "with access check" interpreter. |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 366 | if (kInterpreterImplKind == kMterpImplKind) { |
| 367 | // No access check variants for Mterp. Just use the switch version. |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 368 | if (transaction_active) { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 369 | return ExecuteSwitchImpl<true, true>(self, code_item, shadow_frame, result_register, |
| 370 | false); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 371 | } else { |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 372 | return ExecuteSwitchImpl<true, false>(self, code_item, shadow_frame, result_register, |
| 373 | false); |
| 374 | } |
| 375 | } else if (kInterpreterImplKind == kSwitchImplKind) { |
| 376 | if (transaction_active) { |
| 377 | return ExecuteSwitchImpl<true, true>(self, code_item, shadow_frame, result_register, |
| 378 | false); |
| 379 | } else { |
| 380 | return ExecuteSwitchImpl<true, false>(self, code_item, shadow_frame, result_register, |
| 381 | false); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 382 | } |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 383 | } else { |
| 384 | DCHECK_EQ(kInterpreterImplKind, kComputedGotoImplKind); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 385 | if (transaction_active) { |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 386 | return ExecuteGotoImpl<true, true>(self, code_item, shadow_frame, result_register); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 387 | } else { |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 388 | return ExecuteGotoImpl<true, false>(self, code_item, shadow_frame, result_register); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 389 | } |
Sebastien Hertz | 8ece050 | 2013-08-07 11:26:41 +0200 | [diff] [blame] | 390 | } |
Sebastien Hertz | 233ea8e | 2013-06-06 11:57:09 +0200 | [diff] [blame] | 391 | } |
| 392 | } |
| 393 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 394 | void EnterInterpreterFromInvoke(Thread* self, ArtMethod* method, Object* receiver, |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 395 | uint32_t* args, JValue* result) { |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 396 | DCHECK_EQ(self, Thread::Current()); |
Nicolas Geoffray | 535a3fb | 2014-07-22 15:17:38 +0100 | [diff] [blame] | 397 | bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); |
| 398 | if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { |
jeffhao | d752132 | 2012-11-21 15:38:24 -0800 | [diff] [blame] | 399 | ThrowStackOverflowError(self); |
| 400 | return; |
| 401 | } |
| 402 | |
Mathieu Chartier | e861ebd | 2013-10-09 15:01:21 -0700 | [diff] [blame] | 403 | const char* old_cause = self->StartAssertNoThreadSuspension("EnterInterpreterFromInvoke"); |
Mathieu Chartier | bfd9a43 | 2014-05-21 17:43:44 -0700 | [diff] [blame] | 404 | const DexFile::CodeItem* code_item = method->GetCodeItem(); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 405 | uint16_t num_regs; |
| 406 | uint16_t num_ins; |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 407 | if (code_item != nullptr) { |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 408 | num_regs = code_item->registers_size_; |
| 409 | num_ins = code_item->ins_size_; |
Alex Light | 9139e00 | 2015-10-09 15:59:48 -0700 | [diff] [blame] | 410 | } else if (!method->IsInvokable()) { |
Mathieu Chartier | e861ebd | 2013-10-09 15:01:21 -0700 | [diff] [blame] | 411 | self->EndAssertNoThreadSuspension(old_cause); |
Alex Light | 9139e00 | 2015-10-09 15:59:48 -0700 | [diff] [blame] | 412 | method->ThrowInvocationTimeError(); |
jeffhao | 0a9bb73 | 2012-11-26 12:28:49 -0800 | [diff] [blame] | 413 | return; |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 414 | } else { |
| 415 | DCHECK(method->IsNative()); |
Mathieu Chartier | bfd9a43 | 2014-05-21 17:43:44 -0700 | [diff] [blame] | 416 | num_regs = num_ins = ArtMethod::NumArgRegisters(method->GetShorty()); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 417 | if (!method->IsStatic()) { |
| 418 | num_regs++; |
| 419 | num_ins++; |
| 420 | } |
| 421 | } |
| 422 | // Set up shadow frame with matching number of reference slots to vregs. |
| 423 | ShadowFrame* last_shadow_frame = self->GetManagedStack()->GetTopShadowFrame(); |
Andreas Gampe | b302592 | 2015-09-01 14:45:00 -0700 | [diff] [blame] | 424 | ShadowFrameAllocaUniquePtr shadow_frame_unique_ptr = |
Andreas Gampe | 03ec930 | 2015-08-27 17:41:47 -0700 | [diff] [blame] | 425 | CREATE_SHADOW_FRAME(num_regs, last_shadow_frame, method, /* dex pc */ 0); |
Andreas Gampe | b302592 | 2015-09-01 14:45:00 -0700 | [diff] [blame] | 426 | ShadowFrame* shadow_frame = shadow_frame_unique_ptr.get(); |
Jeff Hao | 6613519 | 2013-05-14 11:02:41 -0700 | [diff] [blame] | 427 | self->PushShadowFrame(shadow_frame); |
Mathieu Chartier | e861ebd | 2013-10-09 15:01:21 -0700 | [diff] [blame] | 428 | |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 429 | size_t cur_reg = num_regs - num_ins; |
| 430 | if (!method->IsStatic()) { |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 431 | CHECK(receiver != nullptr); |
TDYa127 | ce4cc0d | 2012-11-18 16:59:53 -0800 | [diff] [blame] | 432 | shadow_frame->SetVRegReference(cur_reg, receiver); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 433 | ++cur_reg; |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 434 | } |
Mathieu Chartier | bfd9a43 | 2014-05-21 17:43:44 -0700 | [diff] [blame] | 435 | uint32_t shorty_len = 0; |
| 436 | const char* shorty = method->GetShorty(&shorty_len); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 437 | for (size_t shorty_pos = 0, arg_pos = 0; cur_reg < num_regs; ++shorty_pos, ++arg_pos, cur_reg++) { |
Mathieu Chartier | bfd9a43 | 2014-05-21 17:43:44 -0700 | [diff] [blame] | 438 | DCHECK_LT(shorty_pos + 1, shorty_len); |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 439 | switch (shorty[shorty_pos + 1]) { |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 440 | case 'L': { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 441 | Object* o = reinterpret_cast<StackReference<Object>*>(&args[arg_pos])->AsMirrorPtr(); |
TDYa127 | ce4cc0d | 2012-11-18 16:59:53 -0800 | [diff] [blame] | 442 | shadow_frame->SetVRegReference(cur_reg, o); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 443 | break; |
| 444 | } |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 445 | case 'J': case 'D': { |
| 446 | uint64_t wide_value = (static_cast<uint64_t>(args[arg_pos + 1]) << 32) | args[arg_pos]; |
| 447 | shadow_frame->SetVRegLong(cur_reg, wide_value); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 448 | cur_reg++; |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 449 | arg_pos++; |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 450 | break; |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 451 | } |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 452 | default: |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 453 | shadow_frame->SetVReg(cur_reg, args[arg_pos]); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 454 | break; |
| 455 | } |
| 456 | } |
Mathieu Chartier | 92246bb | 2014-02-25 18:22:39 -0800 | [diff] [blame] | 457 | self->EndAssertNoThreadSuspension(old_cause); |
| 458 | // Do this after populating the shadow frame in case EnsureInitialized causes a GC. |
Ian Rogers | 6c5cb21 | 2014-06-18 16:07:20 -0700 | [diff] [blame] | 459 | if (method->IsStatic() && UNLIKELY(!method->GetDeclaringClass()->IsInitialized())) { |
Mathieu Chartier | 92246bb | 2014-02-25 18:22:39 -0800 | [diff] [blame] | 460 | ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 461 | StackHandleScope<1> hs(self); |
| 462 | Handle<mirror::Class> h_class(hs.NewHandle(method->GetDeclaringClass())); |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 463 | if (UNLIKELY(!class_linker->EnsureInitialized(self, h_class, true, true))) { |
Mathieu Chartier | 92246bb | 2014-02-25 18:22:39 -0800 | [diff] [blame] | 464 | CHECK(self->IsExceptionPending()); |
| 465 | self->PopShadowFrame(); |
| 466 | return; |
| 467 | } |
| 468 | } |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 469 | if (LIKELY(!method->IsNative())) { |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 470 | JValue r = Execute(self, code_item, *shadow_frame, JValue()); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 471 | if (result != nullptr) { |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 472 | *result = r; |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 473 | } |
| 474 | } else { |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 475 | // We don't expect to be asked to interpret native code (which is entered via a JNI compiler |
| 476 | // generated stub) except during testing and image writing. |
Mathieu Chartier | 92246bb | 2014-02-25 18:22:39 -0800 | [diff] [blame] | 477 | // Update args to be the args in the shadow frame since the input ones could hold stale |
| 478 | // references pointers due to moving GC. |
| 479 | args = shadow_frame->GetVRegArgs(method->IsStatic() ? 0 : 1); |
Ian Rogers | 64b6d14 | 2012-10-29 16:34:15 -0700 | [diff] [blame] | 480 | if (!Runtime::Current()->IsStarted()) { |
Andreas Gampe | 799681b | 2015-05-15 19:24:12 -0700 | [diff] [blame] | 481 | UnstartedRuntime::Jni(self, method, receiver, args, result); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 482 | } else { |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 483 | InterpreterJni(self, method, shorty, receiver, args, result); |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 484 | } |
| 485 | } |
| 486 | self->PopShadowFrame(); |
| 487 | } |
| 488 | |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 489 | void EnterInterpreterFromDeoptimize(Thread* self, |
| 490 | ShadowFrame* shadow_frame, |
| 491 | bool from_code, |
| 492 | JValue* ret_val) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 493 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Jeff Hao | 11ffc2d | 2013-02-01 11:52:17 -0800 | [diff] [blame] | 494 | JValue value; |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 495 | // Set value to last known result in case the shadow frame chain is empty. |
| 496 | value.SetJ(ret_val->GetJ()); |
Sebastien Hertz | 520633b | 2015-09-08 17:03:36 +0200 | [diff] [blame] | 497 | // Are we executing the first shadow frame? |
| 498 | bool first = true; |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 499 | while (shadow_frame != nullptr) { |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 500 | self->SetTopOfShadowStack(shadow_frame); |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 501 | const DexFile::CodeItem* code_item = shadow_frame->GetMethod()->GetCodeItem(); |
Sebastien Hertz | 270a0e1 | 2015-01-16 19:49:09 +0100 | [diff] [blame] | 502 | const uint32_t dex_pc = shadow_frame->GetDexPC(); |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 503 | uint32_t new_dex_pc = dex_pc; |
Sebastien Hertz | 270a0e1 | 2015-01-16 19:49:09 +0100 | [diff] [blame] | 504 | if (UNLIKELY(self->IsExceptionPending())) { |
Sebastien Hertz | 520633b | 2015-09-08 17:03:36 +0200 | [diff] [blame] | 505 | // If we deoptimize from the QuickExceptionHandler, we already reported the exception to |
| 506 | // the instrumentation. To prevent from reporting it a second time, we simply pass a |
| 507 | // null Instrumentation*. |
Sebastien Hertz | 270a0e1 | 2015-01-16 19:49:09 +0100 | [diff] [blame] | 508 | const instrumentation::Instrumentation* const instrumentation = |
Sebastien Hertz | 520633b | 2015-09-08 17:03:36 +0200 | [diff] [blame] | 509 | first ? nullptr : Runtime::Current()->GetInstrumentation(); |
Sebastien Hertz | 270a0e1 | 2015-01-16 19:49:09 +0100 | [diff] [blame] | 510 | uint32_t found_dex_pc = FindNextInstructionFollowingException(self, *shadow_frame, dex_pc, |
| 511 | instrumentation); |
| 512 | new_dex_pc = found_dex_pc; // the dex pc of a matching catch handler |
| 513 | // or DexFile::kDexNoIndex if there is none. |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 514 | } else if (!from_code) { |
| 515 | // For the debugger and full deoptimization stack, we must go past the invoke |
| 516 | // instruction, as it already executed. |
Mingyao Yang | d43b3ac | 2015-04-01 14:03:04 -0700 | [diff] [blame] | 517 | // TODO: should be tested more once b/17586779 is fixed. |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 518 | const Instruction* instr = Instruction::At(&code_item->insns_[dex_pc]); |
| 519 | DCHECK(instr->IsInvoke()); |
| 520 | new_dex_pc = dex_pc + instr->SizeInCodeUnits(); |
| 521 | } else { |
| 522 | // Nothing to do, the dex_pc is the one at which the code requested |
| 523 | // the deoptimization. |
Sebastien Hertz | 270a0e1 | 2015-01-16 19:49:09 +0100 | [diff] [blame] | 524 | } |
| 525 | if (new_dex_pc != DexFile::kDexNoIndex) { |
| 526 | shadow_frame->SetDexPC(new_dex_pc); |
| 527 | value = Execute(self, code_item, *shadow_frame, value); |
| 528 | } |
Jeff Hao | 11ffc2d | 2013-02-01 11:52:17 -0800 | [diff] [blame] | 529 | ShadowFrame* old_frame = shadow_frame; |
| 530 | shadow_frame = shadow_frame->GetLink(); |
Christopher Ferris | 241a958 | 2015-04-27 15:19:41 -0700 | [diff] [blame] | 531 | ShadowFrame::DeleteDeoptimizedFrame(old_frame); |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 532 | // Following deoptimizations of shadow frames must pass the invoke instruction. |
| 533 | from_code = false; |
Sebastien Hertz | 520633b | 2015-09-08 17:03:36 +0200 | [diff] [blame] | 534 | first = false; |
Jeff Hao | 11ffc2d | 2013-02-01 11:52:17 -0800 | [diff] [blame] | 535 | } |
| 536 | ret_val->SetJ(value.GetJ()); |
| 537 | } |
| 538 | |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 539 | JValue EnterInterpreterFromEntryPoint(Thread* self, const DexFile::CodeItem* code_item, |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 540 | ShadowFrame* shadow_frame) { |
Ian Rogers | f3e9855 | 2013-03-20 15:49:49 -0700 | [diff] [blame] | 541 | DCHECK_EQ(self, Thread::Current()); |
Nicolas Geoffray | 535a3fb | 2014-07-22 15:17:38 +0100 | [diff] [blame] | 542 | bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); |
| 543 | if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { |
Ian Rogers | f3e9855 | 2013-03-20 15:49:49 -0700 | [diff] [blame] | 544 | ThrowStackOverflowError(self); |
| 545 | return JValue(); |
| 546 | } |
| 547 | |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 548 | return Execute(self, code_item, *shadow_frame, JValue()); |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 549 | } |
| 550 | |
Andreas Gampe | 3cfa4d0 | 2015-10-06 17:04:01 -0700 | [diff] [blame] | 551 | void ArtInterpreterToInterpreterBridge(Thread* self, const DexFile::CodeItem* code_item, |
| 552 | ShadowFrame* shadow_frame, JValue* result) { |
Nicolas Geoffray | 535a3fb | 2014-07-22 15:17:38 +0100 | [diff] [blame] | 553 | bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks(); |
| 554 | if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) { |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 555 | ThrowStackOverflowError(self); |
Jeff Hao | 6951067 | 2013-05-21 17:34:55 -0700 | [diff] [blame] | 556 | return; |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 557 | } |
| 558 | |
Mathieu Chartier | e861ebd | 2013-10-09 15:01:21 -0700 | [diff] [blame] | 559 | self->PushShadowFrame(shadow_frame); |
Alex Light | eb7c144 | 2015-08-31 13:17:42 -0700 | [diff] [blame] | 560 | ArtMethod* method = shadow_frame->GetMethod(); |
Sebastien Hertz | c61124b | 2013-09-10 11:44:19 +0200 | [diff] [blame] | 561 | // Ensure static methods are initialized. |
Alex Light | eb7c144 | 2015-08-31 13:17:42 -0700 | [diff] [blame] | 562 | const bool is_static = method->IsStatic(); |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 563 | if (is_static) { |
Alex Light | eb7c144 | 2015-08-31 13:17:42 -0700 | [diff] [blame] | 564 | mirror::Class* declaring_class = method->GetDeclaringClass(); |
Ian Rogers | 6c5cb21 | 2014-06-18 16:07:20 -0700 | [diff] [blame] | 565 | if (UNLIKELY(!declaring_class->IsInitialized())) { |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 566 | StackHandleScope<1> hs(self); |
| 567 | HandleWrapper<Class> h_declaring_class(hs.NewHandleWrapper(&declaring_class)); |
| 568 | if (UNLIKELY(!Runtime::Current()->GetClassLinker()->EnsureInitialized( |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 569 | self, h_declaring_class, true, true))) { |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 570 | DCHECK(self->IsExceptionPending()); |
Mathieu Chartier | e861ebd | 2013-10-09 15:01:21 -0700 | [diff] [blame] | 571 | self->PopShadowFrame(); |
Sebastien Hertz | c61124b | 2013-09-10 11:44:19 +0200 | [diff] [blame] | 572 | return; |
| 573 | } |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 574 | CHECK(h_declaring_class->IsInitializing()); |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 575 | } |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 576 | } |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 577 | |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 578 | if (LIKELY(!shadow_frame->GetMethod()->IsNative())) { |
| 579 | result->SetJ(Execute(self, code_item, *shadow_frame, JValue()).GetJ()); |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 580 | } else { |
| 581 | // We don't expect to be asked to interpret native code (which is entered via a JNI compiler |
| 582 | // generated stub) except during testing and image writing. |
| 583 | CHECK(!Runtime::Current()->IsStarted()); |
Ian Rogers | e94652f | 2014-12-02 11:13:19 -0800 | [diff] [blame] | 584 | Object* receiver = is_static ? nullptr : shadow_frame->GetVRegReference(0); |
| 585 | uint32_t* args = shadow_frame->GetVRegArgs(is_static ? 0 : 1); |
Andreas Gampe | 799681b | 2015-05-15 19:24:12 -0700 | [diff] [blame] | 586 | UnstartedRuntime::Jni(self, shadow_frame->GetMethod(), receiver, args, result); |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 587 | } |
| 588 | |
| 589 | self->PopShadowFrame(); |
Jeff Hao | 1674363 | 2013-05-08 10:59:04 -0700 | [diff] [blame] | 590 | } |
| 591 | |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 592 | void CheckInterpreterAsmConstants() { |
| 593 | CheckMterpAsmConstants(); |
| 594 | } |
| 595 | |
| 596 | void InitInterpreterTls(Thread* self) { |
| 597 | InitMterpTls(self); |
| 598 | } |
| 599 | |
Ian Rogers | 2fa6b2e | 2012-10-17 00:10:17 -0700 | [diff] [blame] | 600 | } // namespace interpreter |
| 601 | } // namespace art |