Gitiles
Code Review Sign In
review.blissroms.org / platform_art / d752132c73072084a3def9257cca4fcee76047b6 / . / src / interpreter / interpreter.cc
blob: 0a66a21c05f28dedddcad00485b9747df45bfac1 [file] [log] [blame]
Ian Rogers2fa6b2e2012-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
17#include "interpreter.h"
18
19#include <math.h>
20
21#include "common_throws.h"
jeffhao373c52f2012-11-20 16:11:52 -0800[diff] [blame]22#include "debugger.h"
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]23#include "dex_instruction.h"
24#include "invoke_arg_array_builder.h"
25#include "logging.h"
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]26#include "nth_caller_visitor.h"
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]27#include "object.h"
28#include "object_utils.h"
29#include "runtime_support.h"
30#include "ScopedLocalRef.h"
31#include "scoped_thread_state_change.h"
32#include "thread.h"
33
34namespace art {
35namespace interpreter {
36
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]37static const int32_t kMaxInt = std::numeric_limits<int32_t>::max();
38static const int32_t kMinInt = std::numeric_limits<int32_t>::min();
39static const int64_t kMaxLong = std::numeric_limits<int64_t>::max();
40static const int64_t kMinLong = std::numeric_limits<int64_t>::min();
41
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]42static void UnstartedRuntimeInvoke(Thread* self, AbstractMethod* target_method,
43 Object* receiver, JValue* args, JValue* result)
44 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
45 // In a runtime that's not started we intercept certain methods to avoid complicated dependency
46 // problems in core libraries.
47 std::string name(PrettyMethod(target_method));
48 if (name == "java.lang.Class java.lang.Class.forName(java.lang.String)") {
49 std::string descriptor(DotToDescriptor(args[0].GetL()->AsString()->ToModifiedUtf8().c_str()));
50 ClassLoader* class_loader = NULL; // shadow_frame.GetMethod()->GetDeclaringClass()->GetClassLoader();
51 Class* found = Runtime::Current()->GetClassLinker()->FindClass(descriptor.c_str(),
52 class_loader);
53 CHECK(found != NULL) << "Class.forName failed in un-started runtime for class: "
54 << PrettyDescriptor(descriptor);
55 result->SetL(found);
56 } else if (name == "java.lang.Object java.lang.Class.newInstance()") {
57 Class* klass = receiver->AsClass();
58 AbstractMethod* c = klass->FindDeclaredDirectMethod("<init>", "()V");
59 CHECK(c != NULL);
60 Object* obj = klass->AllocObject(self);
61 CHECK(obj != NULL);
62 EnterInterpreterFromInvoke(self, c, obj, NULL, NULL);
63 result->SetL(obj);
64 } else if (name == "java.lang.reflect.Field java.lang.Class.getDeclaredField(java.lang.String)") {
65 // Special managed code cut-out to allow field lookup in a un-started runtime that'd fail
66 // going the reflective Dex way.
67 Class* klass = receiver->AsClass();
68 String* name = args[0].GetL()->AsString();
69 Field* found = NULL;
70 FieldHelper fh;
71 ObjectArray<Field>* fields = klass->GetIFields();
72 for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
73 Field* f = fields->Get(i);
74 fh.ChangeField(f);
75 if (name->Equals(fh.GetName())) {
76 found = f;
77 }
78 }
79 if (found == NULL) {
80 fields = klass->GetSFields();
81 for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
82 Field* f = fields->Get(i);
83 fh.ChangeField(f);
84 if (name->Equals(fh.GetName())) {
85 found = f;
86 }
87 }
88 }
89 CHECK(found != NULL)
90 << "Failed to find field in Class.getDeclaredField in un-started runtime. name="
91 << name->ToModifiedUtf8() << " class=" << PrettyDescriptor(klass);
92 // TODO: getDeclaredField calls GetType once the field is found to ensure a
93 // NoClassDefFoundError is thrown if the field's type cannot be resolved.
94 result->SetL(found);
95 } else if (name == "void java.lang.System.arraycopy(java.lang.Object, int, java.lang.Object, int, int)") {
96 // Special case array copying without initializing System.
97 Class* ctype = args[0].GetL()->GetClass()->GetComponentType();
98 jint srcPos = args[1].GetI();
99 jint dstPos = args[3].GetI();
100 jint length = args[4].GetI();
101 if (!ctype->IsPrimitive()) {
102 ObjectArray<Object>* src = args[0].GetL()->AsObjectArray<Object>();
103 ObjectArray<Object>* dst = args[2].GetL()->AsObjectArray<Object>();
104 for (jint i = 0; i < length; ++i) {
105 dst->Set(dstPos + i, src->Get(srcPos + i));
106 }
107 } else if (ctype->IsPrimitiveChar()) {
108 CharArray* src = args[0].GetL()->AsCharArray();
109 CharArray* dst = args[2].GetL()->AsCharArray();
110 for (jint i = 0; i < length; ++i) {
111 dst->Set(dstPos + i, src->Get(srcPos + i));
112 }
113 } else if (ctype->IsPrimitiveInt()) {
114 IntArray* src = args[0].GetL()->AsIntArray();
115 IntArray* dst = args[2].GetL()->AsIntArray();
116 for (jint i = 0; i < length; ++i) {
117 dst->Set(dstPos + i, src->Get(srcPos + i));
118 }
119 } else {
120 UNIMPLEMENTED(FATAL) << "System.arraycopy of unexpected type: " << PrettyDescriptor(ctype);
121 }
122 } else {
123 // Not special, continue with regular interpreter execution.
124 EnterInterpreterFromInvoke(self, target_method, receiver, args, result);
125 }
126}
127
128// Hand select a number of methods to be run in a not yet started runtime without using JNI.
129static void UnstartedRuntimeJni(Thread* self, AbstractMethod* method,
130 Object* receiver, JValue* args, JValue* result)
131 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
132 std::string name(PrettyMethod(method));
133 if (name == "java.lang.ClassLoader dalvik.system.VMStack.getCallingClassLoader()") {
134 result->SetL(NULL);
135 } else if (name == "java.lang.Class dalvik.system.VMStack.getStackClass2()") {
136 NthCallerVisitor visitor(self->GetManagedStack(), NULL, 3);
137 visitor.WalkStack();
138 result->SetL(visitor.caller->GetDeclaringClass());
139 } else if (name == "double java.lang.Math.log(double)") {
140 result->SetD(log(args[0].GetD()));
141 } else if (name == "java.lang.String java.lang.Class.getNameNative()") {
142 result->SetL(receiver->AsClass()->ComputeName());
143 } else if (name == "int java.lang.Float.floatToRawIntBits(float)") {
144 result->SetI(args[0].GetI());
145 } else if (name == "float java.lang.Float.intBitsToFloat(int)") {
146 result->SetF(args[0].GetF());
147 } else if (name == "double java.lang.Math.exp(double)") {
148 result->SetD(exp(args[0].GetD()));
149 } else if (name == "java.lang.Object java.lang.Object.internalClone()") {
150 result->SetL(receiver->Clone(self));
151 } else if (name == "void java.lang.Object.notifyAll()") {
152 receiver->NotifyAll();
153 } else if (name == "int java.lang.String.compareTo(java.lang.String)") {
154 String* rhs = args[0].GetL()->AsString();
155 CHECK(rhs != NULL);
156 result->SetI(receiver->AsString()->CompareTo(rhs));
157 } else if (name == "java.lang.String java.lang.String.intern()") {
158 result->SetL(receiver->AsString()->Intern());
159 } else if (name == "int java.lang.String.fastIndexOf(int, int)") {
160 result->SetI(receiver->AsString()->FastIndexOf(args[0].GetI(), args[1].GetI()));
161 } else if (name == "java.lang.Object java.lang.reflect.Array.createMultiArray(java.lang.Class, int[])") {
162 result->SetL(Array::CreateMultiArray(self, args[0].GetL()->AsClass(), args[1].GetL()->AsIntArray()));
163 } else if (name == "java.lang.Object java.lang.Throwable.nativeFillInStackTrace()") {
164 ScopedObjectAccessUnchecked soa(self);
165 result->SetL(soa.Decode<Object*>(self->CreateInternalStackTrace(soa)));
166 } else if (name == "boolean java.nio.ByteOrder.isLittleEndian()") {
167 result->SetJ(JNI_TRUE);
168 } else if (name == "boolean sun.misc.Unsafe.compareAndSwapInt(java.lang.Object, long, int, int)") {
169 Object* obj = args[0].GetL();
170 jlong offset = args[1].GetJ();
171 jint expectedValue = args[2].GetI();
172 jint newValue = args[3].GetI();
173 byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
174 volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
175 // Note: android_atomic_release_cas() returns 0 on success, not failure.
176 int r = android_atomic_release_cas(expectedValue, newValue, address);
177 result->SetZ(r == 0);
178 } else if (name == "void sun.misc.Unsafe.putObject(java.lang.Object, long, java.lang.Object)") {
179 Object* obj = args[0].GetL();
180 Object* newValue = args[2].GetL();
181 obj->SetFieldObject(MemberOffset(args[1].GetJ()), newValue, false);
182 } else {
183 LOG(FATAL) << "Attempt to invoke native method in non-started runtime: " << name;
184 }
185}
186
187static void InterpreterJni(Thread* self, AbstractMethod* method, StringPiece shorty,
188 Object* receiver, JValue* args, JValue* result)
189 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
190 // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler,
191 // it should be removed and JNI compiled stubs used instead.
192 ScopedObjectAccessUnchecked soa(self);
193 if (method->IsStatic()) {
194 if (shorty == "L") {
195 typedef jobject (fnptr)(JNIEnv*, jclass);
196 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
197 ScopedLocalRef<jclass> klass(soa.Env(),
198 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]199 jobject jresult;
200 {
201 ScopedThreadStateChange tsc(self, kNative);
202 jresult = fn(soa.Env(), klass.get());
203 }
204 result->SetL(soa.Decode<Object*>(jresult));
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]205 } else if (shorty == "V") {
206 typedef void (fnptr)(JNIEnv*, jclass);
207 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
208 ScopedLocalRef<jclass> klass(soa.Env(),
209 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
210 ScopedThreadStateChange tsc(self, kNative);
211 fn(soa.Env(), klass.get());
212 } else if (shorty == "Z") {
213 typedef jboolean (fnptr)(JNIEnv*, jclass);
214 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
215 ScopedLocalRef<jclass> klass(soa.Env(),
216 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
217 ScopedThreadStateChange tsc(self, kNative);
218 result->SetZ(fn(soa.Env(), klass.get()));
219 } else if (shorty == "BI") {
220 typedef jbyte (fnptr)(JNIEnv*, jclass, jint);
221 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
222 ScopedLocalRef<jclass> klass(soa.Env(),
223 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
224 ScopedThreadStateChange tsc(self, kNative);
225 result->SetB(fn(soa.Env(), klass.get(), args[0].GetI()));
226 } else if (shorty == "II") {
227 typedef jint (fnptr)(JNIEnv*, jclass, jint);
228 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
229 ScopedLocalRef<jclass> klass(soa.Env(),
230 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
231 ScopedThreadStateChange tsc(self, kNative);
232 result->SetI(fn(soa.Env(), klass.get(), args[0].GetI()));
233 } else if (shorty == "LL") {
234 typedef jobject (fnptr)(JNIEnv*, jclass, jobject);
235 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
236 ScopedLocalRef<jclass> klass(soa.Env(),
237 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
238 ScopedLocalRef<jobject> arg0(soa.Env(),
239 soa.AddLocalReference<jobject>(args[0].GetL()));
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]240 jobject jresult;
241 {
242 ScopedThreadStateChange tsc(self, kNative);
243 jresult = fn(soa.Env(), klass.get(), arg0.get());
244 }
245 result->SetL(soa.Decode<Object*>(jresult));
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]246 } else if (shorty == "IIZ") {
247 typedef jint (fnptr)(JNIEnv*, jclass, jint, jboolean);
248 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
249 ScopedLocalRef<jclass> klass(soa.Env(),
250 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
251 ScopedThreadStateChange tsc(self, kNative);
252 result->SetI(fn(soa.Env(), klass.get(), args[0].GetI(), args[1].GetZ()));
253 } else if (shorty == "ILI") {
254 typedef jint (fnptr)(JNIEnv*, jclass, jobject, jint);
255 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
256 ScopedLocalRef<jclass> klass(soa.Env(),
257 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
258 ScopedLocalRef<jobject> arg0(soa.Env(),
259 soa.AddLocalReference<jobject>(args[0].GetL()));
260 ScopedThreadStateChange tsc(self, kNative);
261 result->SetI(fn(soa.Env(), klass.get(), arg0.get(), args[1].GetI()));
262 } else if (shorty == "SIZ") {
263 typedef jshort (fnptr)(JNIEnv*, jclass, jint, jboolean);
264 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
265 ScopedLocalRef<jclass> klass(soa.Env(),
266 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
267 ScopedThreadStateChange tsc(self, kNative);
268 result->SetS(fn(soa.Env(), klass.get(), args[0].GetI(), args[1].GetZ()));
269 } else if (shorty == "VIZ") {
270 typedef void (fnptr)(JNIEnv*, jclass, jint, jboolean);
271 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
272 ScopedLocalRef<jclass> klass(soa.Env(),
273 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
274 ScopedThreadStateChange tsc(self, kNative);
275 fn(soa.Env(), klass.get(), args[0].GetI(), args[1].GetZ());
276 } else if (shorty == "ZLL") {
277 typedef jboolean (fnptr)(JNIEnv*, jclass, jobject, jobject);
278 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
279 ScopedLocalRef<jclass> klass(soa.Env(),
280 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
281 ScopedLocalRef<jobject> arg0(soa.Env(),
282 soa.AddLocalReference<jobject>(args[0].GetL()));
283 ScopedLocalRef<jobject> arg1(soa.Env(),
284 soa.AddLocalReference<jobject>(args[1].GetL()));
285 ScopedThreadStateChange tsc(self, kNative);
286 result->SetZ(fn(soa.Env(), klass.get(), arg0.get(), arg1.get()));
287 } else if (shorty == "ZILL") {
288 typedef jboolean (fnptr)(JNIEnv*, jclass, jint, jobject, jobject);
289 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
290 ScopedLocalRef<jclass> klass(soa.Env(),
291 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
292 ScopedLocalRef<jobject> arg1(soa.Env(),
293 soa.AddLocalReference<jobject>(args[1].GetL()));
294 ScopedLocalRef<jobject> arg2(soa.Env(),
295 soa.AddLocalReference<jobject>(args[2].GetL()));
296 ScopedThreadStateChange tsc(self, kNative);
297 result->SetZ(fn(soa.Env(), klass.get(), args[0].GetI(), arg1.get(), arg2.get()));
298 } else if (shorty == "VILII") {
299 typedef void (fnptr)(JNIEnv*, jclass, jint, jobject, jint, jint);
300 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
301 ScopedLocalRef<jclass> klass(soa.Env(),
302 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
303 ScopedLocalRef<jobject> arg1(soa.Env(),
304 soa.AddLocalReference<jobject>(args[1].GetL()));
305 ScopedThreadStateChange tsc(self, kNative);
306 fn(soa.Env(), klass.get(), args[0].GetI(), arg1.get(), args[2].GetI(), args[3].GetI());
307 } else if (shorty == "VLILII") {
308 typedef void (fnptr)(JNIEnv*, jclass, jobject, jint, jobject, jint, jint);
309 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
310 ScopedLocalRef<jclass> klass(soa.Env(),
311 soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
312 ScopedLocalRef<jobject> arg0(soa.Env(),
313 soa.AddLocalReference<jobject>(args[0].GetL()));
314 ScopedLocalRef<jobject> arg2(soa.Env(),
315 soa.AddLocalReference<jobject>(args[2].GetL()));
316 ScopedThreadStateChange tsc(self, kNative);
317 fn(soa.Env(), klass.get(), arg0.get(), args[1].GetI(), arg2.get(), args[3].GetI(),
318 args[4].GetI());
319 } else {
320 LOG(FATAL) << "Do something with static native method: " << PrettyMethod(method)
321 << " shorty: " << shorty;
322 }
323 } else {
324 if (shorty == "L") {
325 typedef jobject (fnptr)(JNIEnv*, jobject);
326 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
327 ScopedLocalRef<jobject> rcvr(soa.Env(),
328 soa.AddLocalReference<jobject>(receiver));
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]329 jobject jresult;
330 {
331 ScopedThreadStateChange tsc(self, kNative);
332 jresult = fn(soa.Env(), rcvr.get());
333 }
334 result->SetL(soa.Decode<Object*>(jresult));
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]335 } else if (shorty == "LL") {
336 typedef jobject (fnptr)(JNIEnv*, jobject, jobject);
337 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
338 ScopedLocalRef<jobject> rcvr(soa.Env(),
339 soa.AddLocalReference<jobject>(receiver));
340 ScopedLocalRef<jobject> arg0(soa.Env(),
341 soa.AddLocalReference<jobject>(args[0].GetL()));
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]342 jobject jresult;
343 {
344 ScopedThreadStateChange tsc(self, kNative);
345 jresult = fn(soa.Env(), rcvr.get(), arg0.get());
346
347 }
348 result->SetL(soa.Decode<Object*>(jresult));
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]349 ScopedThreadStateChange tsc(self, kNative);
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]350 } else if (shorty == "III") {
351 typedef jint (fnptr)(JNIEnv*, jobject, jint, jint);
352 fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
353 ScopedLocalRef<jobject> rcvr(soa.Env(),
354 soa.AddLocalReference<jobject>(receiver));
355 ScopedThreadStateChange tsc(self, kNative);
356 result->SetI(fn(soa.Env(), rcvr.get(), args[0].GetI(), args[1].GetI()));
357 } else {
358 LOG(FATAL) << "Do something with native method: " << PrettyMethod(method)
359 << " shorty: " << shorty;
360 }
361 }
362}
363
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]364static void DoMonitorEnter(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
365 ref->MonitorEnter(self);
366}
367
368static void DoMonitorExit(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
369 ref->MonitorExit(self);
370}
371
372static void DoInvoke(Thread* self, MethodHelper& mh, ShadowFrame& shadow_frame,
373 const DecodedInstruction& dec_insn, InvokeType type, bool is_range,
374 JValue* result)
375 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
376 Object* receiver;
377 if (type == kStatic) {
378 receiver = NULL;
379 } else {
380 receiver = shadow_frame.GetReference(dec_insn.vC);
381 if (UNLIKELY(receiver == NULL)) {
382 ThrowNullPointerExceptionForMethodAccess(shadow_frame.GetMethod(), dec_insn.vB, type);
383 result->SetJ(0);
384 return;
385 }
386 }
387 uint32_t method_idx = dec_insn.vB;
388 AbstractMethod* target_method = FindMethodFromCode(method_idx, receiver,
389 shadow_frame.GetMethod(), self, true,
390 type);
391 if (UNLIKELY(target_method == NULL)) {
392 CHECK(self->IsExceptionPending());
393 result->SetJ(0);
394 return;
395 }
396 mh.ChangeMethod(target_method);
397 ArgArray arg_array(mh.GetShorty(), mh.GetShortyLength());
398 if (is_range) {
399 arg_array.BuildArgArray(shadow_frame, dec_insn.vC + (type != kStatic ? 1 : 0));
400 } else {
401 arg_array.BuildArgArray(shadow_frame, dec_insn.arg + (type != kStatic ? 1 : 0));
402 }
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]403 if (LIKELY(Runtime::Current()->IsStarted())) {
404 target_method->Invoke(self, receiver, arg_array.get(), result);
405 } else {
406 UnstartedRuntimeInvoke(self, target_method, receiver, arg_array.get(), result);
407 }
jeffhaod7521322012-11-21 15:38:24 -0800[diff] [blame^]408 // Check the return type if the result is non-null. We do the GetReturnType
409 // after the null check to avoid resolution when there's an exception pending.
410 if (result->GetL() != NULL && !mh.GetReturnType()->IsPrimitive()) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]411 CHECK(mh.GetReturnType()->IsAssignableFrom(result->GetL()->GetClass()));
412 }
413 mh.ChangeMethod(shadow_frame.GetMethod());
414}
415
416static void DoFieldGet(Thread* self, ShadowFrame& shadow_frame,
417 const DecodedInstruction& dec_insn, FindFieldType find_type,
418 Primitive::Type field_type)
419 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
420 bool is_static = (find_type == StaticObjectRead) || (find_type == StaticPrimitiveRead);
421 uint32_t field_idx = is_static ? dec_insn.vB : dec_insn.vC;
422 Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
423 find_type, Primitive::FieldSize(field_type));
424 if (LIKELY(f != NULL)) {
425 Object* obj;
426 if (is_static) {
427 obj = f->GetDeclaringClass();
428 } else {
429 obj = shadow_frame.GetReference(dec_insn.vB);
430 if (UNLIKELY(obj == NULL)) {
431 ThrowNullPointerExceptionForFieldAccess(f, true);
Ian Rogers689d9f02012-11-20 16:30:29 -0800[diff] [blame]432 return;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]433 }
434 }
435 switch (field_type) {
436 case Primitive::kPrimBoolean:
437 shadow_frame.SetVReg(dec_insn.vA, f->GetBoolean(obj));
438 break;
439 case Primitive::kPrimByte:
440 shadow_frame.SetVReg(dec_insn.vA, f->GetByte(obj));
441 break;
442 case Primitive::kPrimChar:
443 shadow_frame.SetVReg(dec_insn.vA, f->GetChar(obj));
444 break;
445 case Primitive::kPrimShort:
446 shadow_frame.SetVReg(dec_insn.vA, f->GetShort(obj));
447 break;
448 case Primitive::kPrimInt:
449 shadow_frame.SetVReg(dec_insn.vA, f->GetInt(obj));
450 break;
451 case Primitive::kPrimLong:
452 shadow_frame.SetVRegLong(dec_insn.vA, f->GetLong(obj));
453 break;
454 case Primitive::kPrimNot:
455 shadow_frame.SetReferenceAndVReg(dec_insn.vA, f->GetObject(obj));
456 break;
457 default:
458 LOG(FATAL) << "Unreachable: " << field_type;
459 }
460 }
461}
462
463static void DoFieldPut(Thread* self, ShadowFrame& shadow_frame,
464 const DecodedInstruction& dec_insn, FindFieldType find_type,
465 Primitive::Type field_type)
466 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
467 bool is_static = (find_type == StaticObjectWrite) || (find_type == StaticPrimitiveWrite);
468 uint32_t field_idx = is_static ? dec_insn.vB : dec_insn.vC;
469 Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
470 find_type, Primitive::FieldSize(field_type));
471 if (LIKELY(f != NULL)) {
472 Object* obj;
473 if (is_static) {
474 obj = f->GetDeclaringClass();
475 } else {
476 obj = shadow_frame.GetReference(dec_insn.vB);
477 if (UNLIKELY(obj == NULL)) {
478 ThrowNullPointerExceptionForFieldAccess(f, false);
Ian Rogers689d9f02012-11-20 16:30:29 -0800[diff] [blame]479 return;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]480 }
481 }
482 switch (field_type) {
483 case Primitive::kPrimBoolean:
484 f->SetBoolean(obj, shadow_frame.GetVReg(dec_insn.vA));
485 break;
486 case Primitive::kPrimByte:
487 f->SetByte(obj, shadow_frame.GetVReg(dec_insn.vA));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]488 break;
489 case Primitive::kPrimChar:
490 f->SetChar(obj, shadow_frame.GetVReg(dec_insn.vA));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]491 break;
492 case Primitive::kPrimShort:
493 f->SetShort(obj, shadow_frame.GetVReg(dec_insn.vA));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]494 break;
495 case Primitive::kPrimInt:
496 f->SetInt(obj, shadow_frame.GetVReg(dec_insn.vA));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]497 break;
498 case Primitive::kPrimLong:
499 f->SetLong(obj, shadow_frame.GetVRegLong(dec_insn.vA));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]500 break;
501 case Primitive::kPrimNot:
502 f->SetObj(obj, shadow_frame.GetReference(dec_insn.vA));
503 break;
504 default:
505 LOG(FATAL) << "Unreachable: " << field_type;
506 }
507 }
508}
509
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]510static void DoIntDivide(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
511 int32_t dividend, int32_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]512 if (UNLIKELY(divisor == 0)) {
513 self->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
514 } else if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
515 shadow_frame.SetVReg(result_reg, kMinInt);
516 } else {
517 shadow_frame.SetVReg(result_reg, dividend / divisor);
518 }
519}
520
521static void DoIntRemainder(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
522 int32_t dividend, int32_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]523 if (UNLIKELY(divisor == 0)) {
524 self->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
525 } else if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
526 shadow_frame.SetVReg(result_reg, 0);
527 } else {
528 shadow_frame.SetVReg(result_reg, dividend % divisor);
529 }
530}
531
532static void DoLongDivide(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
533 int64_t dividend, int64_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]534 if (UNLIKELY(divisor == 0)) {
535 self->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
536 } else if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
537 shadow_frame.SetVRegLong(result_reg, kMinLong);
538 } else {
539 shadow_frame.SetVRegLong(result_reg, dividend / divisor);
540 }
541}
542
543static void DoLongRemainder(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
544 int64_t dividend, int64_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]545 if (UNLIKELY(divisor == 0)) {
546 self->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
547 } else if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
548 shadow_frame.SetVRegLong(result_reg, 0);
549 } else {
550 shadow_frame.SetVRegLong(result_reg, dividend % divisor);
551 }
552}
553
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]554static JValue Execute(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
555 ShadowFrame& shadow_frame) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
556 const uint16_t* insns = code_item->insns_;
557 const Instruction* inst = Instruction::At(insns + shadow_frame.GetDexPC());
558 JValue result_register;
559 while (true) {
jeffhao373c52f2012-11-20 16:11:52 -0800[diff] [blame]560 CheckSuspend(self);
561 uint32_t dex_pc = inst->GetDexPc(insns);
562 shadow_frame.SetDexPC(dex_pc);
563 Dbg::UpdateDebugger(dex_pc, self);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]564 DecodedInstruction dec_insn(inst);
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]565 const bool kTracing = false;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]566 if (kTracing) {
567 LOG(INFO) << PrettyMethod(shadow_frame.GetMethod())
568 << StringPrintf("\n0x%x: %s\nReferences:",
569 inst->GetDexPc(insns), inst->DumpString(&mh.GetDexFile()).c_str());
570 for (size_t i = 0; i < shadow_frame.NumberOfReferences(); ++i) {
571 Object* o = shadow_frame.GetReference(i);
572 if (o != NULL) {
573 if (o->GetClass()->IsStringClass() && o->AsString()->GetCharArray() != NULL) {
574 LOG(INFO) << i << ": java.lang.String " << static_cast<void*>(o)
575 << " \"" << o->AsString()->ToModifiedUtf8() << "\"";
576 } else {
577 LOG(INFO) << i << ": " << PrettyTypeOf(o) << " " << static_cast<void*>(o);
578 }
579 } else {
580 LOG(INFO) << i << ": null";
581 }
582 }
583 LOG(INFO) << "vregs:";
584 for (size_t i = 0; i < shadow_frame.NumberOfReferences(); ++i) {
585 LOG(INFO) << StringPrintf("%d: %08x", i, shadow_frame.GetVReg(i));
586 }
587 }
588 const Instruction* next_inst = inst->Next();
589 switch (dec_insn.opcode) {
590 case Instruction::NOP:
591 break;
592 case Instruction::MOVE:
593 case Instruction::MOVE_FROM16:
594 case Instruction::MOVE_16:
595 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB));
596 break;
597 case Instruction::MOVE_WIDE:
598 case Instruction::MOVE_WIDE_FROM16:
599 case Instruction::MOVE_WIDE_16:
600 shadow_frame.SetVRegLong(dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB));
601 break;
602 case Instruction::MOVE_OBJECT:
603 case Instruction::MOVE_OBJECT_FROM16:
604 case Instruction::MOVE_OBJECT_16:
605 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB));
606 shadow_frame.SetReference(dec_insn.vA, shadow_frame.GetReference(dec_insn.vB));
607 break;
608 case Instruction::MOVE_RESULT:
609 shadow_frame.SetVReg(dec_insn.vA, result_register.GetI());
610 break;
611 case Instruction::MOVE_RESULT_WIDE:
612 shadow_frame.SetVRegLong(dec_insn.vA, result_register.GetJ());
613 break;
614 case Instruction::MOVE_RESULT_OBJECT:
615 shadow_frame.SetReferenceAndVReg(dec_insn.vA, result_register.GetL());
616 break;
617 case Instruction::MOVE_EXCEPTION: {
618 Throwable* exception = self->GetException();
619 self->ClearException();
620 shadow_frame.SetReferenceAndVReg(dec_insn.vA, exception);
621 break;
622 }
623 case Instruction::RETURN_VOID: {
624 JValue result;
625 result.SetJ(0);
626 return result;
627 }
628 case Instruction::RETURN: {
629 JValue result;
630 result.SetJ(0);
631 result.SetI(shadow_frame.GetVReg(dec_insn.vA));
632 return result;
633 }
634 case Instruction::RETURN_WIDE: {
635 JValue result;
636 result.SetJ(shadow_frame.GetVRegLong(dec_insn.vA));
637 return result;
638 }
639 case Instruction::RETURN_OBJECT: {
640 JValue result;
641 result.SetJ(0);
642 result.SetL(shadow_frame.GetReference(dec_insn.vA));
643 return result;
644 }
645 case Instruction::CONST_4: {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]646 int32_t val = static_cast<int32_t>(dec_insn.vB << 28) >> 28;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]647 shadow_frame.SetVReg(dec_insn.vA, val);
648 if (val == 0) {
649 shadow_frame.SetReference(dec_insn.vA, NULL);
650 }
651 break;
652 }
653 case Instruction::CONST_16: {
654 int32_t val = static_cast<int16_t>(dec_insn.vB);
655 shadow_frame.SetVReg(dec_insn.vA, val);
656 if (val == 0) {
657 shadow_frame.SetReference(dec_insn.vA, NULL);
658 }
659 break;
660 }
661 case Instruction::CONST: {
662 int32_t val = dec_insn.vB;
663 shadow_frame.SetVReg(dec_insn.vA, val);
664 if (val == 0) {
665 shadow_frame.SetReference(dec_insn.vA, NULL);
666 }
667 break;
668 }
669 case Instruction::CONST_HIGH16: {
670 int32_t val = dec_insn.vB << 16;
671 shadow_frame.SetVReg(dec_insn.vA, val);
672 if (val == 0) {
673 shadow_frame.SetReference(dec_insn.vA, NULL);
674 }
675 break;
676 }
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]677 case Instruction::CONST_WIDE_16:
678 shadow_frame.SetVRegLong(dec_insn.vA, static_cast<int16_t>(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]679 break;
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]680 case Instruction::CONST_WIDE_32:
681 shadow_frame.SetVRegLong(dec_insn.vA, static_cast<int32_t>(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]682 break;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]683 case Instruction::CONST_WIDE:
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]684 shadow_frame.SetVRegLong(dec_insn.vA, dec_insn.vB_wide);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]685 break;
686 case Instruction::CONST_WIDE_HIGH16:
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]687 shadow_frame.SetVRegLong(dec_insn.vA, static_cast<uint64_t>(dec_insn.vB) << 48);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]688 break;
689 case Instruction::CONST_STRING:
690 case Instruction::CONST_STRING_JUMBO: {
691 if (UNLIKELY(!String::GetJavaLangString()->IsInitialized())) {
692 Runtime::Current()->GetClassLinker()->EnsureInitialized(String::GetJavaLangString(),
693 true, true);
694 }
695 String* s = mh.ResolveString(dec_insn.vB);
696 shadow_frame.SetReferenceAndVReg(dec_insn.vA, s);
697 break;
698 }
699 case Instruction::CONST_CLASS:
Ian Rogers17ffcab2012-11-20 15:27:41 -0800[diff] [blame]700 shadow_frame.SetReferenceAndVReg(dec_insn.vA, mh.ResolveClass(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]701 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]702 case Instruction::MONITOR_ENTER: {
703 Object* obj = shadow_frame.GetReference(dec_insn.vA);
704 if (UNLIKELY(obj == NULL)) {
705 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
706 } else {
707 DoMonitorEnter(self, obj);
708 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]709 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]710 }
711 case Instruction::MONITOR_EXIT: {
712 Object* obj = shadow_frame.GetReference(dec_insn.vA);
713 if (UNLIKELY(obj == NULL)) {
714 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
715 } else {
716 DoMonitorExit(self, obj);
717 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]718 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]719 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]720 case Instruction::CHECK_CAST: {
721 Class* c = mh.ResolveClass(dec_insn.vB);
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]722 if (UNLIKELY(c == NULL)) {
723 CHECK(self->IsExceptionPending());
724 } else {
725 Object* obj = shadow_frame.GetReference(dec_insn.vA);
726 if (UNLIKELY(obj != NULL && !obj->InstanceOf(c))) {
727 self->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
728 "%s cannot be cast to %s",
729 PrettyDescriptor(obj->GetClass()).c_str(),
730 PrettyDescriptor(c).c_str());
731 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]732 }
733 break;
734 }
735 case Instruction::INSTANCE_OF: {
736 Class* c = mh.ResolveClass(dec_insn.vC);
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]737 if (UNLIKELY(c == NULL)) {
738 CHECK(self->IsExceptionPending());
739 } else {
740 Object* obj = shadow_frame.GetReference(dec_insn.vB);
741 shadow_frame.SetVReg(dec_insn.vA, (obj != NULL && obj->InstanceOf(c)) ? 1 : 0);
742 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]743 break;
744 }
745 case Instruction::ARRAY_LENGTH: {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]746 Object* array = shadow_frame.GetReference(dec_insn.vB);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]747 if (UNLIKELY(array == NULL)) {
748 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
749 break;
750 }
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]751 shadow_frame.SetVReg(dec_insn.vA, array->AsArray()->GetLength());
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]752 break;
753 }
754 case Instruction::NEW_INSTANCE: {
755 Object* obj = AllocObjectFromCode(dec_insn.vB, shadow_frame.GetMethod(), self, true);
756 shadow_frame.SetReferenceAndVReg(dec_insn.vA, obj);
757 break;
758 }
759 case Instruction::NEW_ARRAY: {
760 int32_t length = shadow_frame.GetVReg(dec_insn.vB);
761 Object* obj = AllocArrayFromCode(dec_insn.vC, shadow_frame.GetMethod(), length, self, true);
762 shadow_frame.SetReferenceAndVReg(dec_insn.vA, obj);
763 break;
764 }
765 case Instruction::FILLED_NEW_ARRAY:
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]766 case Instruction::FILLED_NEW_ARRAY_RANGE: {
767 bool is_range = (dec_insn.opcode == Instruction::FILLED_NEW_ARRAY_RANGE);
768 int32_t length = dec_insn.vA;
769 CHECK(is_range || length <= 5);
770 Class* arrayClass = mh.ResolveClass(dec_insn.vB);
771 CHECK(arrayClass->IsArrayClass());
772 if (arrayClass->GetComponentType()->IsPrimitiveInt()) {
773 IntArray* newArray = IntArray::Alloc(self, length);
774 if (newArray != NULL) {
775 for (int32_t i = 0; i < length; ++i) {
776 if (is_range) {
777 newArray->Set(i, shadow_frame.GetVReg(dec_insn.vC + i));
778 } else {
779 newArray->Set(i, shadow_frame.GetVReg(dec_insn.arg[i]));
780 }
781 }
782 }
783 result_register.SetL(newArray);
784 } else {
785 UNIMPLEMENTED(FATAL) << inst->DumpString(&mh.GetDexFile())
786 << " for array type: " << PrettyDescriptor(arrayClass);
787 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]788 break;
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]789 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]790 case Instruction::CMPL_FLOAT: {
791 float val1 = shadow_frame.GetVRegFloat(dec_insn.vB);
792 float val2 = shadow_frame.GetVRegFloat(dec_insn.vC);
793 int32_t result;
794 if (val1 == val2) {
795 result = 0;
796 } else if (val1 > val2) {
797 result = 1;
798 } else {
799 result = -1;
800 }
801 shadow_frame.SetVReg(dec_insn.vA, result);
802 break;
803 }
804 case Instruction::CMPG_FLOAT: {
805 float val1 = shadow_frame.GetVRegFloat(dec_insn.vB);
806 float val2 = shadow_frame.GetVRegFloat(dec_insn.vC);
807 int32_t result;
808 if (val1 == val2) {
809 result = 0;
810 } else if (val1 < val2) {
811 result = -1;
812 } else {
813 result = 1;
814 }
815 shadow_frame.SetVReg(dec_insn.vA, result);
816 break;
817 }
818 case Instruction::CMPL_DOUBLE: {
819 double val1 = shadow_frame.GetVRegDouble(dec_insn.vB);
820 double val2 = shadow_frame.GetVRegDouble(dec_insn.vC);
821 int32_t result;
822 if (val1 == val2) {
823 result = 0;
Ian Rogers58bf0c62012-11-20 16:24:12 -0800[diff] [blame]824 } else if (val1 > val2) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]825 result = 1;
826 } else {
827 result = -1;
828 }
829 shadow_frame.SetVReg(dec_insn.vA, result);
830 break;
831 }
832
833 case Instruction::CMPG_DOUBLE: {
834 double val1 = shadow_frame.GetVRegDouble(dec_insn.vB);
835 double val2 = shadow_frame.GetVRegDouble(dec_insn.vC);
836 int32_t result;
837 if (val1 == val2) {
838 result = 0;
Ian Rogers58bf0c62012-11-20 16:24:12 -0800[diff] [blame]839 } else if (val1 < val2) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]840 result = -1;
841 } else {
842 result = 1;
843 }
844 shadow_frame.SetVReg(dec_insn.vA, result);
845 break;
846 }
847 case Instruction::CMP_LONG: {
848 int64_t val1 = shadow_frame.GetVRegLong(dec_insn.vB);
849 int64_t val2 = shadow_frame.GetVRegLong(dec_insn.vC);
850 int32_t result;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]851 if (val1 > val2) {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]852 result = 1;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]853 } else if (val1 == val2) {
854 result = 0;
855 } else {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]856 result = -1;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]857 }
858 shadow_frame.SetVReg(dec_insn.vA, result);
859 break;
860 }
861 case Instruction::THROW: {
862 Throwable* t = shadow_frame.GetReference(dec_insn.vA)->AsThrowable();
863 self->SetException(t);
864 break;
865 }
866 case Instruction::GOTO:
867 case Instruction::GOTO_16:
868 case Instruction::GOTO_32: {
869 uint32_t dex_pc = inst->GetDexPc(insns);
870 next_inst = Instruction::At(insns + dex_pc + dec_insn.vA);
871 break;
872 }
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]873 case Instruction::PACKED_SWITCH: {
874 uint32_t dex_pc = inst->GetDexPc(insns);
875 const uint16_t* switch_data = insns + dex_pc + dec_insn.vB;
876 int32_t test_val = shadow_frame.GetVReg(dec_insn.vA);
877 CHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kPackedSwitchSignature));
878 uint16_t size = switch_data[1];
879 CHECK_GT(size, 0);
880 const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
881 CHECK(IsAligned<4>(keys));
882 int32_t first_key = keys[0];
883 const int32_t* targets = reinterpret_cast<const int32_t*>(&switch_data[4]);
884 CHECK(IsAligned<4>(targets));
885 int32_t index = test_val - first_key;
886 if (index >= 0 && index < size) {
887 next_inst = Instruction::At(insns + dex_pc + targets[index]);
888 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]889 break;
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]890 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]891 case Instruction::SPARSE_SWITCH: {
892 uint32_t dex_pc = inst->GetDexPc(insns);
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]893 const uint16_t* switch_data = insns + dex_pc + dec_insn.vB;
894 int32_t test_val = shadow_frame.GetVReg(dec_insn.vA);
895 CHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kSparseSwitchSignature));
896 uint16_t size = switch_data[1];
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]897 CHECK_GT(size, 0);
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]898 const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]899 CHECK(IsAligned<4>(keys));
900 const int32_t* entries = keys + size;
901 CHECK(IsAligned<4>(entries));
902 int lo = 0;
903 int hi = size - 1;
904 while (lo <= hi) {
905 int mid = (lo + hi) / 2;
906 int32_t foundVal = keys[mid];
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]907 if (test_val < foundVal) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]908 hi = mid - 1;
Ian Rogers556d6372012-11-20 12:19:36 -0800[diff] [blame]909 } else if (test_val > foundVal) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]910 lo = mid + 1;
911 } else {
912 next_inst = Instruction::At(insns + dex_pc + entries[mid]);
913 break;
914 }
915 }
916 break;
917 }
918 case Instruction::FILL_ARRAY_DATA: {
919 Array* array = shadow_frame.GetReference(dec_insn.vA)->AsArray();
920 if (UNLIKELY(array == NULL)) {
921 Thread::Current()->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
922 "null array in FILL_ARRAY_DATA");
923 break;
924 }
925 DCHECK(array->IsArrayInstance() && !array->IsObjectArray());
926 uint32_t dex_pc = inst->GetDexPc(insns);
927 const Instruction::ArrayDataPayload* payload =
928 reinterpret_cast<const Instruction::ArrayDataPayload*>(insns + dex_pc + dec_insn.vB);
929 if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) {
930 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
931 "failed FILL_ARRAY_DATA; length=%d, index=%d",
932 array->GetLength(), payload->element_count);
933 break;
934 }
935 uint32_t size_in_bytes = payload->element_count * payload->element_width;
936 memcpy(array->GetRawData(payload->element_width), payload->data, size_in_bytes);
937 break;
938 }
939 case Instruction::IF_EQ: {
940 if (shadow_frame.GetVReg(dec_insn.vA) == shadow_frame.GetVReg(dec_insn.vB)) {
941 uint32_t dex_pc = inst->GetDexPc(insns);
942 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
943 }
944 break;
945 }
946 case Instruction::IF_NE: {
947 if (shadow_frame.GetVReg(dec_insn.vA) != shadow_frame.GetVReg(dec_insn.vB)) {
948 uint32_t dex_pc = inst->GetDexPc(insns);
949 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
950 }
951 break;
952 }
953 case Instruction::IF_LT: {
954 if (shadow_frame.GetVReg(dec_insn.vA) < shadow_frame.GetVReg(dec_insn.vB)) {
955 uint32_t dex_pc = inst->GetDexPc(insns);
956 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
957 }
958 break;
959 }
960 case Instruction::IF_GE: {
961 if (shadow_frame.GetVReg(dec_insn.vA) >= shadow_frame.GetVReg(dec_insn.vB)) {
962 uint32_t dex_pc = inst->GetDexPc(insns);
963 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
964 }
965 break;
966 }
967 case Instruction::IF_GT: {
968 if (shadow_frame.GetVReg(dec_insn.vA) > shadow_frame.GetVReg(dec_insn.vB)) {
969 uint32_t dex_pc = inst->GetDexPc(insns);
970 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
971 }
972 break;
973 }
974 case Instruction::IF_LE: {
975 if (shadow_frame.GetVReg(dec_insn.vA) <= shadow_frame.GetVReg(dec_insn.vB)) {
976 uint32_t dex_pc = inst->GetDexPc(insns);
977 next_inst = Instruction::At(insns + dex_pc + dec_insn.vC);
978 }
979 break;
980 }
981 case Instruction::IF_EQZ: {
982 if (shadow_frame.GetVReg(dec_insn.vA) == 0) {
983 uint32_t dex_pc = inst->GetDexPc(insns);
984 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
985 }
986 break;
987 }
988 case Instruction::IF_NEZ: {
989 if (shadow_frame.GetVReg(dec_insn.vA) != 0) {
990 uint32_t dex_pc = inst->GetDexPc(insns);
991 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
992 }
993 break;
994 }
995 case Instruction::IF_LTZ: {
996 if (shadow_frame.GetVReg(dec_insn.vA) < 0) {
997 uint32_t dex_pc = inst->GetDexPc(insns);
998 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
999 }
1000 break;
1001 }
1002 case Instruction::IF_GEZ: {
1003 if (shadow_frame.GetVReg(dec_insn.vA) >= 0) {
1004 uint32_t dex_pc = inst->GetDexPc(insns);
1005 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
1006 }
1007 break;
1008 }
1009 case Instruction::IF_GTZ: {
1010 if (shadow_frame.GetVReg(dec_insn.vA) > 0) {
1011 uint32_t dex_pc = inst->GetDexPc(insns);
1012 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
1013 }
1014 break;
1015 }
1016 case Instruction::IF_LEZ: {
1017 if (shadow_frame.GetVReg(dec_insn.vA) <= 0) {
1018 uint32_t dex_pc = inst->GetDexPc(insns);
1019 next_inst = Instruction::At(insns + dex_pc + dec_insn.vB);
1020 }
1021 break;
1022 }
1023 case Instruction::AGET_BOOLEAN: {
1024 BooleanArray* a = shadow_frame.GetReference(dec_insn.vB)->AsBooleanArray();
1025 if (UNLIKELY(a == NULL)) {
1026 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1027 break;
1028 }
1029 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1030 shadow_frame.SetVReg(dec_insn.vA, a->Get(index));
1031 break;
1032 }
1033 case Instruction::AGET_BYTE: {
1034 ByteArray* a = shadow_frame.GetReference(dec_insn.vB)->AsByteArray();
1035 if (UNLIKELY(a == NULL)) {
1036 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1037 break;
1038 }
1039 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1040 shadow_frame.SetVReg(dec_insn.vA, a->Get(index));
1041 break;
1042 }
1043 case Instruction::AGET_CHAR: {
1044 CharArray* a = shadow_frame.GetReference(dec_insn.vB)->AsCharArray();
1045 if (UNLIKELY(a == NULL)) {
1046 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1047 break;
1048 }
1049 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1050 shadow_frame.SetVReg(dec_insn.vA, a->Get(index));
1051 break;
1052 }
1053 case Instruction::AGET_SHORT: {
1054 ShortArray* a = shadow_frame.GetReference(dec_insn.vB)->AsShortArray();
1055 if (UNLIKELY(a == NULL)) {
1056 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1057 break;
1058 }
1059 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1060 shadow_frame.SetVReg(dec_insn.vA, a->Get(index));
1061 break;
1062 }
1063 case Instruction::AGET: {
1064 IntArray* a = shadow_frame.GetReference(dec_insn.vB)->AsIntArray();
1065 if (UNLIKELY(a == NULL)) {
1066 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1067 break;
1068 }
1069 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1070 shadow_frame.SetVReg(dec_insn.vA, a->Get(index));
1071 break;
1072 }
1073 case Instruction::AGET_WIDE: {
1074 LongArray* a = shadow_frame.GetReference(dec_insn.vB)->AsLongArray();
1075 if (UNLIKELY(a == NULL)) {
1076 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1077 break;
1078 }
1079 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1080 shadow_frame.SetVRegLong(dec_insn.vA, a->Get(index));
1081 break;
1082 }
1083 case Instruction::AGET_OBJECT: {
1084 ObjectArray<Object>* a = shadow_frame.GetReference(dec_insn.vB)->AsObjectArray<Object>();
1085 if (UNLIKELY(a == NULL)) {
1086 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1087 break;
1088 }
1089 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1090 Object* o = a->Get(index);
1091 shadow_frame.SetReferenceAndVReg(dec_insn.vA, o);
1092 break;
1093 }
1094 case Instruction::APUT_BOOLEAN: {
1095 uint8_t val = shadow_frame.GetVReg(dec_insn.vA);
1096 BooleanArray* a = shadow_frame.GetReference(dec_insn.vB)->AsBooleanArray();
1097 if (UNLIKELY(a == NULL)) {
1098 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1099 break;
1100 }
1101 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1102 a->Set(index, val);
1103 break;
1104 }
1105 case Instruction::APUT_BYTE: {
1106 int8_t val = shadow_frame.GetVReg(dec_insn.vA);
1107 ByteArray* a = shadow_frame.GetReference(dec_insn.vB)->AsByteArray();
1108 if (UNLIKELY(a == NULL)) {
1109 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1110 break;
1111 }
1112 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1113 a->Set(index, val);
1114 break;
1115 }
1116 case Instruction::APUT_CHAR: {
1117 uint16_t val = shadow_frame.GetVReg(dec_insn.vA);
1118 CharArray* a = shadow_frame.GetReference(dec_insn.vB)->AsCharArray();
1119 if (UNLIKELY(a == NULL)) {
1120 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1121 break;
1122 }
1123 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1124 a->Set(index, val);
1125 break;
1126 }
1127 case Instruction::APUT_SHORT: {
1128 int16_t val = shadow_frame.GetVReg(dec_insn.vA);
1129 ShortArray* a = shadow_frame.GetReference(dec_insn.vB)->AsShortArray();
1130 if (UNLIKELY(a == NULL)) {
1131 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1132 break;
1133 }
1134 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1135 a->Set(index, val);
1136 break;
1137 }
1138 case Instruction::APUT: {
1139 int32_t val = shadow_frame.GetVReg(dec_insn.vA);
1140 IntArray* a = shadow_frame.GetReference(dec_insn.vB)->AsIntArray();
1141 if (UNLIKELY(a == NULL)) {
1142 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1143 break;
1144 }
1145 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1146 a->Set(index, val);
1147 break;
1148 }
1149 case Instruction::APUT_WIDE: {
1150 int64_t val = shadow_frame.GetVRegLong(dec_insn.vA);
1151 LongArray* a = shadow_frame.GetReference(dec_insn.vB)->AsLongArray();
1152 if (UNLIKELY(a == NULL)) {
1153 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1154 break;
1155 }
1156 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1157 a->Set(index, val);
1158 break;
1159 }
1160 case Instruction::APUT_OBJECT: {
1161 Object* val = shadow_frame.GetReference(dec_insn.vA);
1162 ObjectArray<Object>* a = shadow_frame.GetReference(dec_insn.vB)->AsObjectArray<Object>();
1163 if (UNLIKELY(a == NULL)) {
1164 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetMethod(), inst->GetDexPc(insns));
1165 break;
1166 }
1167 int32_t index = shadow_frame.GetVReg(dec_insn.vC);
1168 a->Set(index, val);
1169 break;
1170 }
1171 case Instruction::IGET_BOOLEAN:
1172 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimBoolean);
1173 break;
1174 case Instruction::IGET_BYTE:
1175 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimByte);
1176 break;
1177 case Instruction::IGET_CHAR:
1178 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimChar);
1179 break;
1180 case Instruction::IGET_SHORT:
1181 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimShort);
1182 break;
1183 case Instruction::IGET:
1184 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimInt);
1185 break;
1186 case Instruction::IGET_WIDE:
1187 DoFieldGet(self, shadow_frame, dec_insn, InstancePrimitiveRead, Primitive::kPrimLong);
1188 break;
1189 case Instruction::IGET_OBJECT:
1190 DoFieldGet(self, shadow_frame, dec_insn, InstanceObjectRead, Primitive::kPrimNot);
1191 break;
1192 case Instruction::SGET_BOOLEAN:
1193 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimBoolean);
1194 break;
1195 case Instruction::SGET_BYTE:
1196 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimByte);
1197 break;
1198 case Instruction::SGET_CHAR:
1199 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimChar);
1200 break;
1201 case Instruction::SGET_SHORT:
1202 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimShort);
1203 break;
1204 case Instruction::SGET:
1205 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimInt);
1206 break;
1207 case Instruction::SGET_WIDE:
1208 DoFieldGet(self, shadow_frame, dec_insn, StaticPrimitiveRead, Primitive::kPrimLong);
1209 break;
1210 case Instruction::SGET_OBJECT:
1211 DoFieldGet(self, shadow_frame, dec_insn, StaticObjectRead, Primitive::kPrimNot);
1212 break;
1213 case Instruction::IPUT_BOOLEAN:
1214 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimBoolean);
1215 break;
1216 case Instruction::IPUT_BYTE:
1217 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimByte);
1218 break;
1219 case Instruction::IPUT_CHAR:
1220 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimChar);
1221 break;
1222 case Instruction::IPUT_SHORT:
1223 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimShort);
1224 break;
1225 case Instruction::IPUT:
1226 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimInt);
1227 break;
1228 case Instruction::IPUT_WIDE:
1229 DoFieldPut(self, shadow_frame, dec_insn, InstancePrimitiveWrite, Primitive::kPrimLong);
1230 break;
1231 case Instruction::IPUT_OBJECT:
1232 DoFieldPut(self, shadow_frame, dec_insn, InstanceObjectWrite, Primitive::kPrimNot);
1233 break;
1234 case Instruction::SPUT_BOOLEAN:
1235 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimBoolean);
1236 break;
1237 case Instruction::SPUT_BYTE:
1238 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimByte);
1239 break;
1240 case Instruction::SPUT_CHAR:
1241 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimChar);
1242 break;
1243 case Instruction::SPUT_SHORT:
1244 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimShort);
1245 break;
1246 case Instruction::SPUT:
1247 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimInt);
1248 break;
1249 case Instruction::SPUT_WIDE:
1250 DoFieldPut(self, shadow_frame, dec_insn, StaticPrimitiveWrite, Primitive::kPrimLong);
1251 break;
1252 case Instruction::SPUT_OBJECT:
1253 DoFieldPut(self, shadow_frame, dec_insn, StaticObjectWrite, Primitive::kPrimNot);
1254 break;
1255 case Instruction::INVOKE_VIRTUAL:
1256 DoInvoke(self, mh, shadow_frame, dec_insn, kVirtual, false, &result_register);
1257 break;
1258 case Instruction::INVOKE_VIRTUAL_RANGE:
1259 DoInvoke(self, mh, shadow_frame, dec_insn, kVirtual, true, &result_register);
1260 break;
1261 case Instruction::INVOKE_SUPER:
1262 DoInvoke(self, mh, shadow_frame, dec_insn, kSuper, false, &result_register);
1263 break;
1264 case Instruction::INVOKE_SUPER_RANGE:
1265 DoInvoke(self, mh, shadow_frame, dec_insn, kSuper, true, &result_register);
1266 break;
1267 case Instruction::INVOKE_DIRECT:
1268 DoInvoke(self, mh, shadow_frame, dec_insn, kDirect, false, &result_register);
1269 break;
1270 case Instruction::INVOKE_DIRECT_RANGE:
1271 DoInvoke(self, mh, shadow_frame, dec_insn, kDirect, true, &result_register);
1272 break;
1273 case Instruction::INVOKE_INTERFACE:
1274 DoInvoke(self, mh, shadow_frame, dec_insn, kInterface, false, &result_register);
1275 break;
1276 case Instruction::INVOKE_INTERFACE_RANGE:
1277 DoInvoke(self, mh, shadow_frame, dec_insn, kInterface, true, &result_register);
1278 break;
1279 case Instruction::INVOKE_STATIC:
1280 DoInvoke(self, mh, shadow_frame, dec_insn, kStatic, false, &result_register);
1281 break;
1282 case Instruction::INVOKE_STATIC_RANGE:
1283 DoInvoke(self, mh, shadow_frame, dec_insn, kStatic, true, &result_register);
1284 break;
1285 case Instruction::NEG_INT:
1286 shadow_frame.SetVReg(dec_insn.vA, -shadow_frame.GetVReg(dec_insn.vB));
1287 break;
1288 case Instruction::NOT_INT:
1289 shadow_frame.SetVReg(dec_insn.vA, 0 ^ shadow_frame.GetVReg(dec_insn.vB));
1290 break;
1291 case Instruction::NEG_LONG:
1292 shadow_frame.SetVRegLong(dec_insn.vA, -shadow_frame.GetVRegLong(dec_insn.vB));
1293 break;
1294 case Instruction::NOT_LONG:
1295 shadow_frame.SetVRegLong(dec_insn.vA, 0 ^ shadow_frame.GetVRegLong(dec_insn.vB));
1296 break;
1297 case Instruction::NEG_FLOAT:
1298 shadow_frame.SetVRegFloat(dec_insn.vA, -shadow_frame.GetVRegFloat(dec_insn.vB));
1299 break;
1300 case Instruction::NEG_DOUBLE:
1301 shadow_frame.SetVRegDouble(dec_insn.vA, -shadow_frame.GetVRegDouble(dec_insn.vB));
1302 break;
1303 case Instruction::INT_TO_LONG:
1304 shadow_frame.SetVRegLong(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB));
1305 break;
1306 case Instruction::INT_TO_FLOAT:
1307 shadow_frame.SetVRegFloat(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB));
1308 break;
1309 case Instruction::INT_TO_DOUBLE:
1310 shadow_frame.SetVRegDouble(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB));
1311 break;
1312 case Instruction::LONG_TO_INT:
1313 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB));
1314 break;
1315 case Instruction::LONG_TO_FLOAT:
1316 shadow_frame.SetVRegFloat(dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB));
1317 break;
1318 case Instruction::LONG_TO_DOUBLE:
1319 shadow_frame.SetVRegDouble(dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB));
1320 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1321 case Instruction::FLOAT_TO_INT: {
1322 float val = shadow_frame.GetVRegFloat(dec_insn.vB);
1323 if (val != val) {
1324 shadow_frame.SetVReg(dec_insn.vA, 0);
1325 } else if (val > static_cast<float>(kMaxInt)) {
1326 shadow_frame.SetVReg(dec_insn.vA, kMaxInt);
1327 } else if (val < static_cast<float>(kMinInt)) {
1328 shadow_frame.SetVReg(dec_insn.vA, kMinInt);
1329 } else {
1330 shadow_frame.SetVReg(dec_insn.vA, val);
1331 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1332 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1333 }
1334 case Instruction::FLOAT_TO_LONG: {
1335 float val = shadow_frame.GetVRegFloat(dec_insn.vB);
1336 if (val != val) {
1337 shadow_frame.SetVRegLong(dec_insn.vA, 0);
1338 } else if (val > static_cast<float>(kMaxLong)) {
1339 shadow_frame.SetVRegLong(dec_insn.vA, kMaxLong);
1340 } else if (val < static_cast<float>(kMinLong)) {
1341 shadow_frame.SetVRegLong(dec_insn.vA, kMinLong);
1342 } else {
1343 shadow_frame.SetVRegLong(dec_insn.vA, val);
1344 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1345 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1346 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1347 case Instruction::FLOAT_TO_DOUBLE:
1348 shadow_frame.SetVRegDouble(dec_insn.vA, shadow_frame.GetVRegFloat(dec_insn.vB));
1349 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1350 case Instruction::DOUBLE_TO_INT: {
1351 double val = shadow_frame.GetVRegDouble(dec_insn.vB);
1352 if (val != val) {
1353 shadow_frame.SetVReg(dec_insn.vA, 0);
1354 } else if (val > static_cast<double>(kMaxInt)) {
1355 shadow_frame.SetVReg(dec_insn.vA, kMaxInt);
1356 } else if (val < static_cast<double>(kMinInt)) {
1357 shadow_frame.SetVReg(dec_insn.vA, kMinInt);
1358 } else {
1359 shadow_frame.SetVReg(dec_insn.vA, val);
1360 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1361 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1362 }
1363 case Instruction::DOUBLE_TO_LONG: {
1364 double val = shadow_frame.GetVRegDouble(dec_insn.vB);
1365 if (val != val) {
1366 shadow_frame.SetVRegLong(dec_insn.vA, 0);
1367 } else if (val > static_cast<double>(kMaxLong)) {
1368 shadow_frame.SetVRegLong(dec_insn.vA, kMaxLong);
1369 } else if (val < static_cast<double>(kMinLong)) {
1370 shadow_frame.SetVRegLong(dec_insn.vA, kMinLong);
1371 } else {
1372 shadow_frame.SetVRegLong(dec_insn.vA, val);
1373 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1374 break;
jeffhao87a6edd2012-11-20 18:05:18 -0800[diff] [blame]1375 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1376 case Instruction::DOUBLE_TO_FLOAT:
1377 shadow_frame.SetVRegFloat(dec_insn.vA, shadow_frame.GetVRegDouble(dec_insn.vB));
1378 break;
1379 case Instruction::INT_TO_BYTE:
1380 shadow_frame.SetVReg(dec_insn.vA, static_cast<int8_t>(shadow_frame.GetVReg(dec_insn.vB)));
1381 break;
1382 case Instruction::INT_TO_CHAR:
1383 shadow_frame.SetVReg(dec_insn.vA, static_cast<uint16_t>(shadow_frame.GetVReg(dec_insn.vB)));
1384 break;
1385 case Instruction::INT_TO_SHORT:
1386 shadow_frame.SetVReg(dec_insn.vA, static_cast<int16_t>(shadow_frame.GetVReg(dec_insn.vB)));
1387 break;
1388 case Instruction::ADD_INT:
1389 shadow_frame.SetVReg(dec_insn.vA,
1390 shadow_frame.GetVReg(dec_insn.vB) + shadow_frame.GetVReg(dec_insn.vC));
1391 break;
1392 case Instruction::SUB_INT:
1393 shadow_frame.SetVReg(dec_insn.vA,
1394 shadow_frame.GetVReg(dec_insn.vB) - shadow_frame.GetVReg(dec_insn.vC));
1395 break;
1396 case Instruction::MUL_INT:
1397 shadow_frame.SetVReg(dec_insn.vA,
1398 shadow_frame.GetVReg(dec_insn.vB) * shadow_frame.GetVReg(dec_insn.vC));
1399 break;
1400 case Instruction::REM_INT:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1401 DoIntRemainder(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB),
1402 shadow_frame.GetVReg(dec_insn.vC));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1403 break;
1404 case Instruction::DIV_INT:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1405 DoIntDivide(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB),
1406 shadow_frame.GetVReg(dec_insn.vC));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1407 break;
1408 case Instruction::SHL_INT:
1409 shadow_frame.SetVReg(dec_insn.vA,
1410 shadow_frame.GetVReg(dec_insn.vB) << shadow_frame.GetVReg(dec_insn.vC));
1411 break;
1412 case Instruction::SHR_INT:
1413 shadow_frame.SetVReg(dec_insn.vA,
1414 shadow_frame.GetVReg(dec_insn.vB) >> shadow_frame.GetVReg(dec_insn.vC));
1415 break;
1416 case Instruction::USHR_INT:
1417 shadow_frame.SetVReg(dec_insn.vA,
1418 static_cast<uint32_t>(shadow_frame.GetVReg(dec_insn.vB)) >>
1419 shadow_frame.GetVReg(dec_insn.vC));
1420 break;
1421 case Instruction::AND_INT:
1422 shadow_frame.SetVReg(dec_insn.vA,
1423 shadow_frame.GetVReg(dec_insn.vB) & shadow_frame.GetVReg(dec_insn.vC));
1424 break;
1425 case Instruction::OR_INT:
1426 shadow_frame.SetVReg(dec_insn.vA,
1427 shadow_frame.GetVReg(dec_insn.vB) | shadow_frame.GetVReg(dec_insn.vC));
1428 break;
1429 case Instruction::XOR_INT:
1430 shadow_frame.SetVReg(dec_insn.vA,
1431 shadow_frame.GetVReg(dec_insn.vB) ^ shadow_frame.GetVReg(dec_insn.vC));
1432 break;
1433 case Instruction::ADD_LONG:
1434 shadow_frame.SetVRegLong(dec_insn.vA,
1435 shadow_frame.GetVRegLong(dec_insn.vB) +
1436 shadow_frame.GetVRegLong(dec_insn.vC));
1437 break;
1438 case Instruction::SUB_LONG:
1439 shadow_frame.SetVRegLong(dec_insn.vA,
1440 shadow_frame.GetVRegLong(dec_insn.vB) -
1441 shadow_frame.GetVRegLong(dec_insn.vC));
1442 break;
1443 case Instruction::MUL_LONG:
1444 shadow_frame.SetVRegLong(dec_insn.vA,
1445 shadow_frame.GetVRegLong(dec_insn.vB) *
1446 shadow_frame.GetVRegLong(dec_insn.vC));
1447 break;
1448 case Instruction::DIV_LONG:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1449 DoLongDivide(self, shadow_frame, dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB),
1450 shadow_frame.GetVRegLong(dec_insn.vC));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1451 break;
1452 case Instruction::REM_LONG:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1453 DoLongRemainder(self, shadow_frame, dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vB),
1454 shadow_frame.GetVRegLong(dec_insn.vC));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1455 break;
1456 case Instruction::AND_LONG:
1457 shadow_frame.SetVRegLong(dec_insn.vA,
1458 shadow_frame.GetVRegLong(dec_insn.vB) &
1459 shadow_frame.GetVRegLong(dec_insn.vC));
1460 break;
1461 case Instruction::OR_LONG:
1462 shadow_frame.SetVRegLong(dec_insn.vA,
1463 shadow_frame.GetVRegLong(dec_insn.vB) |
1464 shadow_frame.GetVRegLong(dec_insn.vC));
1465 break;
1466 case Instruction::XOR_LONG:
1467 shadow_frame.SetVRegLong(dec_insn.vA,
1468 shadow_frame.GetVRegLong(dec_insn.vB) ^
1469 shadow_frame.GetVRegLong(dec_insn.vC));
1470 break;
1471 case Instruction::SHL_LONG:
1472 shadow_frame.SetVRegLong(dec_insn.vA,
1473 shadow_frame.GetVRegLong(dec_insn.vB) <<
1474 shadow_frame.GetVReg(dec_insn.vC));
1475 break;
1476 case Instruction::SHR_LONG:
1477 shadow_frame.SetVRegLong(dec_insn.vA,
1478 shadow_frame.GetVRegLong(dec_insn.vB) >>
1479 shadow_frame.GetVReg(dec_insn.vC));
1480 break;
1481 case Instruction::USHR_LONG:
1482 shadow_frame.SetVRegLong(dec_insn.vA,
1483 static_cast<uint64_t>(shadow_frame.GetVRegLong(dec_insn.vB)) >>
1484 shadow_frame.GetVReg(dec_insn.vC));
1485 break;
1486 case Instruction::ADD_FLOAT:
1487 shadow_frame.SetVRegFloat(dec_insn.vA,
1488 shadow_frame.GetVRegFloat(dec_insn.vB) +
1489 shadow_frame.GetVRegFloat(dec_insn.vC));
1490 break;
1491 case Instruction::SUB_FLOAT:
1492 shadow_frame.SetVRegFloat(dec_insn.vA,
1493 shadow_frame.GetVRegFloat(dec_insn.vB) -
1494 shadow_frame.GetVRegFloat(dec_insn.vC));
1495 break;
1496 case Instruction::MUL_FLOAT:
1497 shadow_frame.SetVRegFloat(dec_insn.vA,
1498 shadow_frame.GetVRegFloat(dec_insn.vB) *
1499 shadow_frame.GetVRegFloat(dec_insn.vC));
1500 break;
1501 case Instruction::DIV_FLOAT:
1502 shadow_frame.SetVRegFloat(dec_insn.vA,
1503 shadow_frame.GetVRegFloat(dec_insn.vB) /
1504 shadow_frame.GetVRegFloat(dec_insn.vC));
1505 break;
1506 case Instruction::REM_FLOAT:
1507 shadow_frame.SetVRegFloat(dec_insn.vA,
1508 fmodf(shadow_frame.GetVRegFloat(dec_insn.vB),
1509 shadow_frame.GetVRegFloat(dec_insn.vC)));
1510 break;
1511 case Instruction::ADD_DOUBLE:
1512 shadow_frame.SetVRegDouble(dec_insn.vA,
1513 shadow_frame.GetVRegDouble(dec_insn.vB) +
1514 shadow_frame.GetVRegDouble(dec_insn.vC));
1515 break;
1516 case Instruction::SUB_DOUBLE:
1517 shadow_frame.SetVRegDouble(dec_insn.vA,
1518 shadow_frame.GetVRegDouble(dec_insn.vB) -
1519 shadow_frame.GetVRegDouble(dec_insn.vC));
1520 break;
1521 case Instruction::MUL_DOUBLE:
1522 shadow_frame.SetVRegDouble(dec_insn.vA,
1523 shadow_frame.GetVRegDouble(dec_insn.vB) *
1524 shadow_frame.GetVRegDouble(dec_insn.vC));
1525 break;
1526 case Instruction::DIV_DOUBLE:
1527 shadow_frame.SetVRegDouble(dec_insn.vA,
1528 shadow_frame.GetVRegDouble(dec_insn.vB) /
1529 shadow_frame.GetVRegDouble(dec_insn.vC));
1530 break;
1531 case Instruction::REM_DOUBLE:
1532 shadow_frame.SetVRegDouble(dec_insn.vA,
1533 fmod(shadow_frame.GetVRegDouble(dec_insn.vB),
1534 shadow_frame.GetVRegDouble(dec_insn.vC)));
1535 break;
1536 case Instruction::ADD_INT_2ADDR:
1537 shadow_frame.SetVReg(dec_insn.vA,
1538 shadow_frame.GetVReg(dec_insn.vA) + shadow_frame.GetVReg(dec_insn.vB));
1539 break;
1540 case Instruction::SUB_INT_2ADDR:
1541 shadow_frame.SetVReg(dec_insn.vA,
1542 shadow_frame.GetVReg(dec_insn.vA) - shadow_frame.GetVReg(dec_insn.vB));
1543 break;
1544 case Instruction::MUL_INT_2ADDR:
1545 shadow_frame.SetVReg(dec_insn.vA,
1546 shadow_frame.GetVReg(dec_insn.vA) * shadow_frame.GetVReg(dec_insn.vB));
1547 break;
1548 case Instruction::REM_INT_2ADDR:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1549 DoIntRemainder(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vA),
1550 shadow_frame.GetVReg(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1551 break;
1552 case Instruction::SHL_INT_2ADDR:
1553 shadow_frame.SetVReg(dec_insn.vA,
1554 shadow_frame.GetVReg(dec_insn.vA) << shadow_frame.GetVReg(dec_insn.vB));
1555 break;
1556 case Instruction::SHR_INT_2ADDR:
1557 shadow_frame.SetVReg(dec_insn.vA,
1558 shadow_frame.GetVReg(dec_insn.vA) >> shadow_frame.GetVReg(dec_insn.vB));
1559 break;
1560 case Instruction::USHR_INT_2ADDR:
1561 shadow_frame.SetVReg(dec_insn.vA,
1562 static_cast<uint32_t>(shadow_frame.GetVReg(dec_insn.vA)) >>
1563 shadow_frame.GetVReg(dec_insn.vB));
1564 break;
1565 case Instruction::AND_INT_2ADDR:
1566 shadow_frame.SetVReg(dec_insn.vA,
1567 shadow_frame.GetVReg(dec_insn.vA) & shadow_frame.GetVReg(dec_insn.vB));
1568 break;
1569 case Instruction::OR_INT_2ADDR:
1570 shadow_frame.SetVReg(dec_insn.vA,
1571 shadow_frame.GetVReg(dec_insn.vA) | shadow_frame.GetVReg(dec_insn.vB));
1572 break;
1573 case Instruction::XOR_INT_2ADDR:
1574 shadow_frame.SetVReg(dec_insn.vA,
1575 shadow_frame.GetVReg(dec_insn.vA) ^ shadow_frame.GetVReg(dec_insn.vB));
1576 break;
1577 case Instruction::DIV_INT_2ADDR:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1578 DoIntDivide(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vA),
1579 shadow_frame.GetVReg(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1580 break;
1581 case Instruction::ADD_LONG_2ADDR:
1582 shadow_frame.SetVRegLong(dec_insn.vA,
1583 shadow_frame.GetVRegLong(dec_insn.vA) +
1584 shadow_frame.GetVRegLong(dec_insn.vB));
1585 break;
1586 case Instruction::SUB_LONG_2ADDR:
1587 shadow_frame.SetVRegLong(dec_insn.vA,
1588 shadow_frame.GetVRegLong(dec_insn.vA) -
1589 shadow_frame.GetVRegLong(dec_insn.vB));
1590 break;
1591 case Instruction::MUL_LONG_2ADDR:
1592 shadow_frame.SetVRegLong(dec_insn.vA,
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1593 shadow_frame.GetVRegLong(dec_insn.vA) *
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1594 shadow_frame.GetVRegLong(dec_insn.vB));
1595 break;
1596 case Instruction::DIV_LONG_2ADDR:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1597 DoLongDivide(self, shadow_frame, dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vA),
1598 shadow_frame.GetVRegLong(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1599 break;
1600 case Instruction::REM_LONG_2ADDR:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1601 DoLongRemainder(self, shadow_frame, dec_insn.vA, shadow_frame.GetVRegLong(dec_insn.vA),
1602 shadow_frame.GetVRegLong(dec_insn.vB));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1603 break;
1604 case Instruction::AND_LONG_2ADDR:
1605 shadow_frame.SetVRegLong(dec_insn.vA,
1606 shadow_frame.GetVRegLong(dec_insn.vA) &
1607 shadow_frame.GetVRegLong(dec_insn.vB));
1608 break;
1609 case Instruction::OR_LONG_2ADDR:
1610 shadow_frame.SetVRegLong(dec_insn.vA,
1611 shadow_frame.GetVRegLong(dec_insn.vA) |
1612 shadow_frame.GetVRegLong(dec_insn.vB));
1613 break;
1614 case Instruction::XOR_LONG_2ADDR:
1615 shadow_frame.SetVRegLong(dec_insn.vA,
1616 shadow_frame.GetVRegLong(dec_insn.vA) ^
1617 shadow_frame.GetVRegLong(dec_insn.vB));
1618 break;
1619 case Instruction::SHL_LONG_2ADDR:
1620 shadow_frame.SetVRegLong(dec_insn.vA,
1621 shadow_frame.GetVRegLong(dec_insn.vA) <<
1622 shadow_frame.GetVReg(dec_insn.vB));
1623 break;
1624 case Instruction::SHR_LONG_2ADDR:
1625 shadow_frame.SetVRegLong(dec_insn.vA,
1626 shadow_frame.GetVRegLong(dec_insn.vA) >>
1627 shadow_frame.GetVReg(dec_insn.vB));
1628 break;
1629 case Instruction::USHR_LONG_2ADDR:
1630 shadow_frame.SetVRegLong(dec_insn.vA,
1631 static_cast<uint64_t>(shadow_frame.GetVRegLong(dec_insn.vA)) >>
1632 shadow_frame.GetVReg(dec_insn.vB));
1633 break;
1634 case Instruction::ADD_FLOAT_2ADDR:
1635 shadow_frame.SetVRegFloat(dec_insn.vA,
1636 shadow_frame.GetVRegFloat(dec_insn.vA) +
1637 shadow_frame.GetVRegFloat(dec_insn.vB));
1638 break;
1639 case Instruction::SUB_FLOAT_2ADDR:
1640 shadow_frame.SetVRegFloat(dec_insn.vA,
1641 shadow_frame.GetVRegFloat(dec_insn.vA) -
1642 shadow_frame.GetVRegFloat(dec_insn.vB));
1643 break;
1644 case Instruction::MUL_FLOAT_2ADDR:
1645 shadow_frame.SetVRegFloat(dec_insn.vA,
1646 shadow_frame.GetVRegFloat(dec_insn.vA) *
1647 shadow_frame.GetVRegFloat(dec_insn.vB));
1648 break;
1649 case Instruction::DIV_FLOAT_2ADDR:
1650 shadow_frame.SetVRegFloat(dec_insn.vA,
1651 shadow_frame.GetVRegFloat(dec_insn.vA) /
1652 shadow_frame.GetVRegFloat(dec_insn.vB));
1653 break;
1654 case Instruction::REM_FLOAT_2ADDR:
1655 shadow_frame.SetVRegFloat(dec_insn.vA,
1656 fmodf(shadow_frame.GetVRegFloat(dec_insn.vA),
1657 shadow_frame.GetVRegFloat(dec_insn.vB)));
1658 break;
1659 case Instruction::ADD_DOUBLE_2ADDR:
1660 shadow_frame.SetVRegDouble(dec_insn.vA,
1661 shadow_frame.GetVRegDouble(dec_insn.vA) +
1662 shadow_frame.GetVRegDouble(dec_insn.vB));
1663 break;
1664 case Instruction::SUB_DOUBLE_2ADDR:
1665 shadow_frame.SetVRegDouble(dec_insn.vA,
1666 shadow_frame.GetVRegDouble(dec_insn.vA) -
1667 shadow_frame.GetVRegDouble(dec_insn.vB));
1668 break;
1669 case Instruction::MUL_DOUBLE_2ADDR:
1670 shadow_frame.SetVRegDouble(dec_insn.vA,
1671 shadow_frame.GetVRegDouble(dec_insn.vA) *
1672 shadow_frame.GetVRegDouble(dec_insn.vB));
1673 break;
1674 case Instruction::DIV_DOUBLE_2ADDR:
1675 shadow_frame.SetVRegDouble(dec_insn.vA,
1676 shadow_frame.GetVRegDouble(dec_insn.vA) /
1677 shadow_frame.GetVRegDouble(dec_insn.vB));
1678 break;
1679 case Instruction::REM_DOUBLE_2ADDR:
1680 shadow_frame.SetVRegDouble(dec_insn.vA,
1681 fmod(shadow_frame.GetVRegDouble(dec_insn.vA),
1682 shadow_frame.GetVRegDouble(dec_insn.vB)));
1683 break;
1684 case Instruction::ADD_INT_LIT16:
1685 case Instruction::ADD_INT_LIT8:
1686 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) + dec_insn.vC);
1687 break;
1688 case Instruction::RSUB_INT:
1689 case Instruction::RSUB_INT_LIT8:
1690 shadow_frame.SetVReg(dec_insn.vA, dec_insn.vC - shadow_frame.GetVReg(dec_insn.vB));
1691 break;
1692 case Instruction::MUL_INT_LIT16:
1693 case Instruction::MUL_INT_LIT8:
1694 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) * dec_insn.vC);
1695 break;
1696 case Instruction::DIV_INT_LIT16:
1697 case Instruction::DIV_INT_LIT8:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1698 DoIntDivide(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB),
1699 dec_insn.vC);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1700 break;
1701 case Instruction::REM_INT_LIT16:
1702 case Instruction::REM_INT_LIT8:
jeffhaod91398c2012-11-20 17:17:33 -0800[diff] [blame]1703 DoIntRemainder(self, shadow_frame, dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB),
1704 dec_insn.vC);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1705 break;
1706 case Instruction::AND_INT_LIT16:
1707 case Instruction::AND_INT_LIT8:
1708 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) & dec_insn.vC);
1709 break;
1710 case Instruction::OR_INT_LIT16:
1711 case Instruction::OR_INT_LIT8:
1712 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) | dec_insn.vC);
1713 break;
1714 case Instruction::XOR_INT_LIT16:
1715 case Instruction::XOR_INT_LIT8:
1716 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) ^ dec_insn.vC);
1717 break;
1718 case Instruction::SHL_INT_LIT8:
1719 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) << dec_insn.vC);
1720 break;
1721 case Instruction::SHR_INT_LIT8:
1722 shadow_frame.SetVReg(dec_insn.vA, shadow_frame.GetVReg(dec_insn.vB) >> dec_insn.vC);
1723 break;
1724 case Instruction::USHR_INT_LIT8:
1725 shadow_frame.SetVReg(dec_insn.vA,
1726 static_cast<uint32_t>(shadow_frame.GetVReg(dec_insn.vB)) >>
1727 dec_insn.vC);
1728 break;
1729 default:
1730 LOG(FATAL) << "Unexpected instruction: " << inst->DumpString(&mh.GetDexFile());
1731 break;
1732 }
1733 if (UNLIKELY(self->IsExceptionPending())) {
1734 uint32_t found_dex_pc =
1735 shadow_frame.GetMethod()->FindCatchBlock(self->GetException()->GetClass(),
1736 inst->GetDexPc(insns));
1737 if (found_dex_pc == DexFile::kDexNoIndex) {
1738 JValue result;
1739 result.SetJ(0);
1740 return result; // Handler in caller.
1741 } else {
1742 next_inst = Instruction::At(insns + found_dex_pc);
1743 }
1744 }
1745 inst = next_inst;
1746 }
1747}
1748
1749void EnterInterpreterFromInvoke(Thread* self, AbstractMethod* method, Object* receiver,
1750 JValue* args, JValue* result) {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1751 DCHECK_EQ(self, Thread::Current());
jeffhaod7521322012-11-21 15:38:24 -0800[diff] [blame^]1752 if (__builtin_frame_address(0) < self->GetStackEnd()) {
1753 ThrowStackOverflowError(self);
1754 return;
1755 }
1756
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1757 MethodHelper mh(method);
1758 const DexFile::CodeItem* code_item = mh.GetCodeItem();
1759 uint16_t num_regs;
1760 uint16_t num_ins;
1761 if (code_item != NULL) {
1762 num_regs = code_item->registers_size_;
1763 num_ins = code_item->ins_size_;
1764 } else {
1765 DCHECK(method->IsNative());
1766 num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
1767 if (!method->IsStatic()) {
1768 num_regs++;
1769 num_ins++;
1770 }
1771 }
1772 // Set up shadow frame with matching number of reference slots to vregs.
1773 ShadowFrame* last_shadow_frame = self->GetManagedStack()->GetTopShadowFrame();
1774 UniquePtr<ShadowFrame> shadow_frame(ShadowFrame::Create(num_regs, num_regs,
1775 (last_shadow_frame == NULL) ? NULL : last_shadow_frame->GetLink(),
1776 method, 0));
1777 self->PushShadowFrame(shadow_frame.get());
1778 size_t cur_reg = num_regs - num_ins;
1779 if (!method->IsStatic()) {
1780 CHECK(receiver != NULL);
1781 shadow_frame->SetReferenceAndVReg(cur_reg, receiver);
1782 ++cur_reg;
1783 } else if (!method->GetDeclaringClass()->IsInitializing()) {
1784 Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(),
1785 true, true);
1786 CHECK(method->GetDeclaringClass()->IsInitializing());
1787 }
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1788 const char* shorty = mh.GetShorty();
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1789 size_t arg_pos = 0;
1790 for (; cur_reg < num_regs; ++cur_reg, ++arg_pos) {
1791 DCHECK_LT(arg_pos + 1, mh.GetShortyLength());
1792 switch (shorty[arg_pos + 1]) {
1793 case 'L': {
1794 Object* o = args[arg_pos].GetL();
1795 shadow_frame->SetReferenceAndVReg(cur_reg, o);
1796 break;
1797 }
1798 case 'J': case 'D':
1799 shadow_frame->SetVRegLong(cur_reg, args[arg_pos].GetJ());
1800 cur_reg++;
1801 break;
1802 default:
1803 shadow_frame->SetVReg(cur_reg, args[arg_pos].GetI());
1804 break;
1805 }
1806 }
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1807 if (LIKELY(!method->IsNative())) {
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1808 JValue r = Execute(self, mh, code_item, *shadow_frame.get());
1809 if (result != NULL) {
1810 *result = r;
1811 }
1812 } else {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1813 // We don't expect to be asked to interpret native code (which is entered via a JNI compiler
1814 // generated stub) except during testing and image writing.
1815 if (!Runtime::Current()->IsStarted()) {
1816 UnstartedRuntimeJni(self, method, receiver, args, result);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1817 } else {
Ian Rogers64b6d142012-10-29 16:34:15 -0700[diff] [blame]1818 InterpreterJni(self, method, shorty, receiver, args, result);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700[diff] [blame]1819 }
1820 }
1821 self->PopShadowFrame();
1822}
1823
1824} // namespace interpreter
1825} // namespace art