src/interpreter/interpreter.cc

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "interpreter.h"

#include <math.h>

#include "base/logging.h"
#include "class_linker-inl.h"
#include "common_throws.h"
#include "dex_file-inl.h"
#include "dex_instruction-inl.h"
#include "gc/card_table-inl.h"
#include "invoke_arg_array_builder.h"
#include "nth_caller_visitor.h"
#include "mirror/class.h"
#include "mirror/class-inl.h"
#include "mirror/field-inl.h"
#include "mirror/abstract_method.h"
#include "mirror/abstract_method-inl.h"
#include "mirror/object-inl.h"
#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "runtime_support.h"
#include "ScopedLocalRef.h"
#include "scoped_thread_state_change.h"
#include "thread.h"

using namespace art::mirror;

namespace art {

namespace interpreter {

static const int32_t kMaxInt = std::numeric_limits<int32_t>::max();
static const int32_t kMinInt = std::numeric_limits<int32_t>::min();
static const int64_t kMaxLong = std::numeric_limits<int64_t>::max();
static const int64_t kMinLong = std::numeric_limits<int64_t>::min();

static void UnstartedRuntimeInvoke(Thread* self, AbstractMethod* target_method,
                                   ShadowFrame* shadow_frame, JValue* result, size_t arg_offset)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  // In a runtime that's not started we intercept certain methods to avoid complicated dependency
  // problems in core libraries.
  std::string name(PrettyMethod(target_method));
  if (name == "java.lang.Class java.lang.Class.forName(java.lang.String)") {
    std::string descriptor(DotToDescriptor(shadow_frame->GetVRegReference(arg_offset)->AsString()->ToModifiedUtf8().c_str()));
    ClassLoader* class_loader = NULL; // shadow_frame.GetMethod()->GetDeclaringClass()->GetClassLoader();
    Class* found = Runtime::Current()->GetClassLinker()->FindClass(descriptor.c_str(),
                                                                   class_loader);
    CHECK(found != NULL) << "Class.forName failed in un-started runtime for class: "
        << PrettyDescriptor(descriptor);
    result->SetL(found);
  } else if (name == "java.lang.Object java.lang.Class.newInstance()") {
    Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
    AbstractMethod* c = klass->FindDeclaredDirectMethod("<init>", "()V");
    CHECK(c != NULL);
    Object* obj = klass->AllocObject(self);
    CHECK(obj != NULL);
    EnterInterpreterFromInvoke(self, c, obj, NULL, NULL);
    result->SetL(obj);
  } else if (name == "java.lang.reflect.Field java.lang.Class.getDeclaredField(java.lang.String)") {
    // Special managed code cut-out to allow field lookup in a un-started runtime that'd fail
    // going the reflective Dex way.
    Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
    String* name = shadow_frame->GetVRegReference(arg_offset + 1)->AsString();
    Field* found = NULL;
    FieldHelper fh;
    ObjectArray<Field>* fields = klass->GetIFields();
    for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
      Field* f = fields->Get(i);
      fh.ChangeField(f);
      if (name->Equals(fh.GetName())) {
        found = f;
      }
    }
    if (found == NULL) {
      fields = klass->GetSFields();
      for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
        Field* f = fields->Get(i);
        fh.ChangeField(f);
        if (name->Equals(fh.GetName())) {
          found = f;
        }
      }
    }
    CHECK(found != NULL)
      << "Failed to find field in Class.getDeclaredField in un-started runtime. name="
      << name->ToModifiedUtf8() << " class=" << PrettyDescriptor(klass);
    // TODO: getDeclaredField calls GetType once the field is found to ensure a
    //       NoClassDefFoundError is thrown if the field's type cannot be resolved.
    result->SetL(found);
  } else if (name == "void java.lang.System.arraycopy(java.lang.Object, int, java.lang.Object, int, int)") {
    // Special case array copying without initializing System.
    Class* ctype = shadow_frame->GetVRegReference(arg_offset)->GetClass()->GetComponentType();
    jint srcPos = shadow_frame->GetVReg(arg_offset + 1);
    jint dstPos = shadow_frame->GetVReg(arg_offset + 3);
    jint length = shadow_frame->GetVReg(arg_offset + 4);
    if (!ctype->IsPrimitive()) {
      ObjectArray<Object>* src = shadow_frame->GetVRegReference(arg_offset)->AsObjectArray<Object>();
      ObjectArray<Object>* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsObjectArray<Object>();
      for (jint i = 0; i < length; ++i) {
        dst->Set(dstPos + i, src->Get(srcPos + i));
      }
    } else if (ctype->IsPrimitiveChar()) {
      CharArray* src = shadow_frame->GetVRegReference(arg_offset)->AsCharArray();
      CharArray* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsCharArray();
      for (jint i = 0; i < length; ++i) {
        dst->Set(dstPos + i, src->Get(srcPos + i));
      }
    } else if (ctype->IsPrimitiveInt()) {
      IntArray* src = shadow_frame->GetVRegReference(arg_offset)->AsIntArray();
      IntArray* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsIntArray();
      for (jint i = 0; i < length; ++i) {
        dst->Set(dstPos + i, src->Get(srcPos + i));
      }
    } else {
      UNIMPLEMENTED(FATAL) << "System.arraycopy of unexpected type: " << PrettyDescriptor(ctype);
    }
  } else {
    // Not special, continue with regular interpreter execution.
    result->SetJ(EnterInterpreterFromInterpreter(self, shadow_frame).GetJ());
  }
}

// Hand select a number of methods to be run in a not yet started runtime without using JNI.
static void UnstartedRuntimeJni(Thread* self, AbstractMethod* method,
                                Object* receiver, uint32_t* args, JValue* result)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  std::string name(PrettyMethod(method));
  if (name == "java.lang.ClassLoader dalvik.system.VMStack.getCallingClassLoader()") {
    result->SetL(NULL);
  } else if (name == "java.lang.Class dalvik.system.VMStack.getStackClass2()") {
    NthCallerVisitor visitor(self, 3);
    visitor.WalkStack();
    result->SetL(visitor.caller->GetDeclaringClass());
  } else if (name == "double java.lang.Math.log(double)") {
    JValue value;
    value.SetJ((static_cast<uint64_t>(args[1]) << 32) | args[0]);
    result->SetD(log(value.GetD()));
  } else if (name == "java.lang.String java.lang.Class.getNameNative()") {
    result->SetL(receiver->AsClass()->ComputeName());
  } else if (name == "int java.lang.Float.floatToRawIntBits(float)") {
    result->SetI(args[0]);
  } else if (name == "float java.lang.Float.intBitsToFloat(int)") {
    result->SetI(args[0]);
  } else if (name == "double java.lang.Math.exp(double)") {
    JValue value;
    value.SetJ((static_cast<uint64_t>(args[1]) << 32) | args[0]);
    result->SetD(exp(value.GetD()));
  } else if (name == "java.lang.Object java.lang.Object.internalClone()") {
    result->SetL(receiver->Clone(self));
  } else if (name == "void java.lang.Object.notifyAll()") {
    receiver->NotifyAll(self);
  } else if (name == "int java.lang.String.compareTo(java.lang.String)") {
    String* rhs = reinterpret_cast<Object*>(args[0])->AsString();
    CHECK(rhs != NULL);
    result->SetI(receiver->AsString()->CompareTo(rhs));
  } else if (name == "java.lang.String java.lang.String.intern()") {
    result->SetL(receiver->AsString()->Intern());
  } else if (name == "int java.lang.String.fastIndexOf(int, int)") {
    result->SetI(receiver->AsString()->FastIndexOf(args[0], args[1]));
  } else if (name == "java.lang.Object java.lang.reflect.Array.createMultiArray(java.lang.Class, int[])") {
    result->SetL(Array::CreateMultiArray(self, reinterpret_cast<Object*>(args[0])->AsClass(), reinterpret_cast<Object*>(args[1])->AsIntArray()));
  } else if (name == "java.lang.Object java.lang.Throwable.nativeFillInStackTrace()") {
    ScopedObjectAccessUnchecked soa(self);
    result->SetL(soa.Decode<Object*>(self->CreateInternalStackTrace(soa)));
  } else if (name == "boolean java.nio.ByteOrder.isLittleEndian()") {
    result->SetJ(JNI_TRUE);
  } else if (name == "boolean sun.misc.Unsafe.compareAndSwapInt(java.lang.Object, long, int, int)") {
    Object* obj = reinterpret_cast<Object*>(args[0]);
    jlong offset = (static_cast<uint64_t>(args[2]) << 32) | args[1];
    jint expectedValue = args[3];
    jint newValue = args[4];
    byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
    volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
    // Note: android_atomic_release_cas() returns 0 on success, not failure.
    int r = android_atomic_release_cas(expectedValue, newValue, address);
    result->SetZ(r == 0);
  } else if (name == "void sun.misc.Unsafe.putObject(java.lang.Object, long, java.lang.Object)") {
    Object* obj = reinterpret_cast<Object*>(args[0]);
    Object* newValue = reinterpret_cast<Object*>(args[3]);
    obj->SetFieldObject(MemberOffset((static_cast<uint64_t>(args[2]) << 32) | args[1]), newValue, false);
  } else {
    LOG(FATAL) << "Attempt to invoke native method in non-started runtime: " << name;
  }
}

static void InterpreterJni(Thread* self, AbstractMethod* method, StringPiece shorty,
                           Object* receiver, uint32_t* args, JValue* result)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler,
  //       it should be removed and JNI compiled stubs used instead.
  ScopedObjectAccessUnchecked soa(self);
  if (method->IsStatic()) {
    if (shorty == "L") {
      typedef jobject (fnptr)(JNIEnv*, jclass);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      jobject jresult;
      {
        ScopedThreadStateChange tsc(self, kNative);
        jresult = fn(soa.Env(), klass.get());
      }
      result->SetL(soa.Decode<Object*>(jresult));
    } else if (shorty == "V") {
      typedef void (fnptr)(JNIEnv*, jclass);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      fn(soa.Env(), klass.get());
    } else if (shorty == "Z") {
      typedef jboolean (fnptr)(JNIEnv*, jclass);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetZ(fn(soa.Env(), klass.get()));
    } else if (shorty == "BI") {
      typedef jbyte (fnptr)(JNIEnv*, jclass, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetB(fn(soa.Env(), klass.get(), args[0]));
    } else if (shorty == "II") {
      typedef jint (fnptr)(JNIEnv*, jclass, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetI(fn(soa.Env(), klass.get(), args[0]));
    } else if (shorty == "LL") {
      typedef jobject (fnptr)(JNIEnv*, jclass, jobject);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg0(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[0])));
      jobject jresult;
      {
        ScopedThreadStateChange tsc(self, kNative);
        jresult = fn(soa.Env(), klass.get(), arg0.get());
      }
      result->SetL(soa.Decode<Object*>(jresult));
    } else if (shorty == "IIZ") {
      typedef jint (fnptr)(JNIEnv*, jclass, jint, jboolean);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetI(fn(soa.Env(), klass.get(), args[0], args[1]));
    } else if (shorty == "ILI") {
      typedef jint (fnptr)(JNIEnv*, jclass, jobject, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg0(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[0])));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetI(fn(soa.Env(), klass.get(), arg0.get(), args[1]));
    } else if (shorty == "SIZ") {
      typedef jshort (fnptr)(JNIEnv*, jclass, jint, jboolean);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetS(fn(soa.Env(), klass.get(), args[0], args[1]));
    } else if (shorty == "VIZ") {
      typedef void (fnptr)(JNIEnv*, jclass, jint, jboolean);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedThreadStateChange tsc(self, kNative);
      fn(soa.Env(), klass.get(), args[0], args[1]);
    } else if (shorty == "ZLL") {
      typedef jboolean (fnptr)(JNIEnv*, jclass, jobject, jobject);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg0(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[0])));
      ScopedLocalRef<jobject> arg1(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[1])));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetZ(fn(soa.Env(), klass.get(), arg0.get(), arg1.get()));
    } else if (shorty == "ZILL") {
      typedef jboolean (fnptr)(JNIEnv*, jclass, jint, jobject, jobject);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg1(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[1])));
      ScopedLocalRef<jobject> arg2(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[2])));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetZ(fn(soa.Env(), klass.get(), args[0], arg1.get(), arg2.get()));
    } else if (shorty == "VILII") {
      typedef void (fnptr)(JNIEnv*, jclass, jint, jobject, jint, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg1(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[1])));
      ScopedThreadStateChange tsc(self, kNative);
      fn(soa.Env(), klass.get(), args[0], arg1.get(), args[2], args[3]);
    } else if (shorty == "VLILII") {
      typedef void (fnptr)(JNIEnv*, jclass, jobject, jint, jobject, jint, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jclass> klass(soa.Env(),
                                   soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
      ScopedLocalRef<jobject> arg0(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[0])));
      ScopedLocalRef<jobject> arg2(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[2])));
      ScopedThreadStateChange tsc(self, kNative);
      fn(soa.Env(), klass.get(), arg0.get(), args[1], arg2.get(), args[3], args[4]);
    } else {
      LOG(FATAL) << "Do something with static native method: " << PrettyMethod(method)
          << " shorty: " << shorty;
    }
  } else {
    if (shorty == "L") {
      typedef jobject (fnptr)(JNIEnv*, jobject);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jobject> rcvr(soa.Env(),
                                   soa.AddLocalReference<jobject>(receiver));
      jobject jresult;
      {
        ScopedThreadStateChange tsc(self, kNative);
        jresult = fn(soa.Env(), rcvr.get());
      }
      result->SetL(soa.Decode<Object*>(jresult));
    } else if (shorty == "LL") {
      typedef jobject (fnptr)(JNIEnv*, jobject, jobject);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jobject> rcvr(soa.Env(),
                                   soa.AddLocalReference<jobject>(receiver));
      ScopedLocalRef<jobject> arg0(soa.Env(),
                                   soa.AddLocalReference<jobject>(reinterpret_cast<Object*>(args[0])));
      jobject jresult;
      {
        ScopedThreadStateChange tsc(self, kNative);
        jresult = fn(soa.Env(), rcvr.get(), arg0.get());

      }
      result->SetL(soa.Decode<Object*>(jresult));
      ScopedThreadStateChange tsc(self, kNative);
    } else if (shorty == "III") {
      typedef jint (fnptr)(JNIEnv*, jobject, jint, jint);
      fnptr* fn = reinterpret_cast<fnptr*>(method->GetNativeMethod());
      ScopedLocalRef<jobject> rcvr(soa.Env(),
                                   soa.AddLocalReference<jobject>(receiver));
      ScopedThreadStateChange tsc(self, kNative);
      result->SetI(fn(soa.Env(), rcvr.get(), args[0], args[1]));
    } else {
      LOG(FATAL) << "Do something with native method: " << PrettyMethod(method)
          << " shorty: " << shorty;
    }
  }
}

static void DoMonitorEnter(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
  ref->MonitorEnter(self);
}

static void DoMonitorExit(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
  ref->MonitorExit(self);
}

static void DoInvoke(Thread* self, MethodHelper& mh, ShadowFrame& shadow_frame,
                     const Instruction* inst, InvokeType type, bool is_range,
                     JValue* result)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  uint32_t vregC = (is_range) ? inst->VRegC_3rc() : inst->VRegC_35c();
  Object* receiver;
  if (type == kStatic) {
    receiver = NULL;
  } else {
    receiver = shadow_frame.GetVRegReference(vregC);
  }
  uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
  AbstractMethod* target_method = FindMethodFromCode(method_idx, receiver,
                                                     shadow_frame.GetMethod(),
                                                     self, true, type);
  if (UNLIKELY(target_method == NULL)) {
    CHECK(self->IsExceptionPending());
    result->SetJ(0);
    return;
  }
  mh.ChangeMethod(target_method);

  const DexFile::CodeItem* code_item = mh.GetCodeItem();
  uint16_t num_regs;
  uint16_t num_ins;
  if (code_item != NULL) {
    num_regs = code_item->registers_size_;
    num_ins = code_item->ins_size_;
  } else if (target_method->IsAbstract()) {
    ThrowLocation throw_location = self->GetCurrentLocationForThrow();
    self->ThrowNewExceptionF(throw_location, "Ljava/lang/AbstractMethodError;",
                             "abstract method \"%s\"", PrettyMethod(target_method).c_str());
    return;
  } else {
    DCHECK(target_method->IsNative() || target_method->IsProxyMethod());
    num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
    if (!target_method->IsStatic()) {
      num_regs++;
      num_ins++;
    }
  }

  Runtime* runtime = Runtime::Current();
  UniquePtr<ShadowFrame> new_shadow_frame(ShadowFrame::Create(num_regs, &shadow_frame,
                                                              target_method, 0));
  size_t cur_reg = num_regs - num_ins;
  if (receiver != NULL) {
    new_shadow_frame->SetVRegReference(cur_reg, receiver);
    ++cur_reg;
  }

  size_t arg_offset = (receiver == NULL) ? 0 : 1;
  const char* shorty = mh.GetShorty();
  uint32_t arg[5];
  if (!is_range) {
    inst->GetArgs(arg);
  }
  for (size_t shorty_pos = 0; cur_reg < num_regs; ++shorty_pos, cur_reg++, arg_offset++) {
    DCHECK_LT(shorty_pos + 1, mh.GetShortyLength());
    size_t arg_pos = is_range ? vregC + arg_offset : arg[arg_offset];
    switch (shorty[shorty_pos + 1]) {
      case 'L': {
        Object* o = shadow_frame.GetVRegReference(arg_pos);
        new_shadow_frame->SetVRegReference(cur_reg, o);
        break;
      }
      case 'J': case 'D': {
        uint64_t wide_value = (static_cast<uint64_t>(shadow_frame.GetVReg(arg_pos + 1)) << 32) |
                              static_cast<uint32_t>(shadow_frame.GetVReg(arg_pos));
        new_shadow_frame->SetVRegLong(cur_reg, wide_value);
        cur_reg++;
        arg_offset++;
        break;
      }
      default:
        new_shadow_frame->SetVReg(cur_reg, shadow_frame.GetVReg(arg_pos));
        break;
    }
  }

  if (LIKELY(runtime->IsStarted())) {
    result->SetJ((target_method->GetEntryPointFromInterpreter())(self, new_shadow_frame.get()).GetJ());
  } else {
    UnstartedRuntimeInvoke(self, target_method, new_shadow_frame.get(), result, num_regs - num_ins);
  }
  mh.ChangeMethod(shadow_frame.GetMethod());
}

static void DoFieldGet(Thread* self, ShadowFrame& shadow_frame,
                       const Instruction* inst, FindFieldType find_type,
                       Primitive::Type field_type)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  bool is_static = (find_type == StaticObjectRead) || (find_type == StaticPrimitiveRead);
  uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
  Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
                               find_type, Primitive::FieldSize(field_type));
  if (UNLIKELY(f == NULL)) {
    CHECK(self->IsExceptionPending());
    return;
  }
  Object* obj;
  if (is_static) {
    obj = f->GetDeclaringClass();
  } else {
    obj = shadow_frame.GetVRegReference(inst->VRegB_22c());
    if (UNLIKELY(obj == NULL)) {
      ThrowNullPointerExceptionForFieldAccess(shadow_frame.GetCurrentLocationForThrow(), f, true);
      return;
    }
  }
  uint32_t vregA = is_static ? inst->VRegA_21c() : inst->VRegA_22c();
  switch (field_type) {
    case Primitive::kPrimBoolean:
      shadow_frame.SetVReg(vregA, f->GetBoolean(obj));
      break;
    case Primitive::kPrimByte:
      shadow_frame.SetVReg(vregA, f->GetByte(obj));
      break;
    case Primitive::kPrimChar:
      shadow_frame.SetVReg(vregA, f->GetChar(obj));
      break;
    case Primitive::kPrimShort:
      shadow_frame.SetVReg(vregA, f->GetShort(obj));
      break;
    case Primitive::kPrimInt:
      shadow_frame.SetVReg(vregA, f->GetInt(obj));
      break;
    case Primitive::kPrimLong:
      shadow_frame.SetVRegLong(vregA, f->GetLong(obj));
      break;
    case Primitive::kPrimNot:
      shadow_frame.SetVRegReference(vregA, f->GetObject(obj));
      break;
    default:
      LOG(FATAL) << "Unreachable: " << field_type;
  }
}

static void DoFieldPut(Thread* self, ShadowFrame& shadow_frame,
                       const Instruction* inst, FindFieldType find_type,
                       Primitive::Type field_type)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  bool is_static = (find_type == StaticObjectWrite) || (find_type == StaticPrimitiveWrite);
  uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
  Field* f = FindFieldFromCode(field_idx, shadow_frame.GetMethod(), self,
                               find_type, Primitive::FieldSize(field_type));
  if (UNLIKELY(f == NULL)) {
    CHECK(self->IsExceptionPending());
    return;
  }
  Object* obj;
  if (is_static) {
    obj = f->GetDeclaringClass();
  } else {
    obj = shadow_frame.GetVRegReference(inst->VRegB_22c());
    if (UNLIKELY(obj == NULL)) {
      ThrowNullPointerExceptionForFieldAccess(shadow_frame.GetCurrentLocationForThrow(),
                                              f, false);
      return;
    }
  }
  uint32_t vregA = is_static ? inst->VRegA_21c() : inst->VRegA_22c();
  switch (field_type) {
    case Primitive::kPrimBoolean:
      f->SetBoolean(obj, shadow_frame.GetVReg(vregA));
      break;
    case Primitive::kPrimByte:
      f->SetByte(obj, shadow_frame.GetVReg(vregA));
      break;
    case Primitive::kPrimChar:
      f->SetChar(obj, shadow_frame.GetVReg(vregA));
      break;
    case Primitive::kPrimShort:
      f->SetShort(obj, shadow_frame.GetVReg(vregA));
      break;
    case Primitive::kPrimInt:
      f->SetInt(obj, shadow_frame.GetVReg(vregA));
      break;
    case Primitive::kPrimLong:
      f->SetLong(obj, shadow_frame.GetVRegLong(vregA));
      break;
    case Primitive::kPrimNot:
      f->SetObj(obj, shadow_frame.GetVRegReference(vregA));
      break;
    default:
      LOG(FATAL) << "Unreachable: " << field_type;
  }
}

static String* ResolveString(Thread* self, MethodHelper& mh, uint32_t string_idx) {
  Class* java_lang_string_class = String::GetJavaLangString();
  if (UNLIKELY(!java_lang_string_class->IsInitialized())) {
    ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
    if (UNLIKELY(!class_linker->EnsureInitialized(java_lang_string_class,
                                                  true, true))) {
      DCHECK(self->IsExceptionPending());
      return NULL;
    }
  }
  return mh.ResolveString(string_idx);
}

static void DoIntDivide(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
    int32_t dividend, int32_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (UNLIKELY(divisor == 0)) {
    ThrowArithmeticExceptionDivideByZero(self);
  } else if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
    shadow_frame.SetVReg(result_reg, kMinInt);
  } else {
    shadow_frame.SetVReg(result_reg, dividend / divisor);
  }
}

static void DoIntRemainder(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
    int32_t dividend, int32_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (UNLIKELY(divisor == 0)) {
    ThrowArithmeticExceptionDivideByZero(self);
  } else if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
    shadow_frame.SetVReg(result_reg, 0);
  } else {
    shadow_frame.SetVReg(result_reg, dividend % divisor);
  }
}

static void DoLongDivide(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
    int64_t dividend, int64_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (UNLIKELY(divisor == 0)) {
    ThrowArithmeticExceptionDivideByZero(self);
  } else if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
    shadow_frame.SetVRegLong(result_reg, kMinLong);
  } else {
    shadow_frame.SetVRegLong(result_reg, dividend / divisor);
  }
}

static void DoLongRemainder(Thread* self, ShadowFrame& shadow_frame, size_t result_reg,
    int64_t dividend, int64_t divisor) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (UNLIKELY(divisor == 0)) {
    ThrowArithmeticExceptionDivideByZero(self);
  } else if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
    shadow_frame.SetVRegLong(result_reg, 0);
  } else {
    shadow_frame.SetVRegLong(result_reg, dividend % divisor);
  }
}

static JValue Execute(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
                      ShadowFrame& shadow_frame, JValue result_register)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (UNLIKELY(!shadow_frame.HasReferenceArray())) {
    LOG(FATAL) << "Invalid shadow frame for interpreter use";
    return JValue();
  }
  self->VerifyStack();
  instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
  const uint16_t* const insns = code_item->insns_;

  // As the 'this' object won't change during the execution of current code, we
  // want to cache it in local variables. Nevertheless, in order to let the
  // garbage collector access it, we store it into sirt references.
  SirtRef<Object> this_object_ref(self, shadow_frame.GetThisObject());

  const Instruction* inst = Instruction::At(insns + shadow_frame.GetDexPC());
  if (inst->GetDexPc(insns) == 0) {  // We are entering the method as opposed to deoptimizing..
    instrumentation->MethodEnterEvent(self, this_object_ref.get(),
                                      shadow_frame.GetMethod(), 0);
  }
  while (true) {
    CheckSuspend(self);
    const uint32_t dex_pc = inst->GetDexPc(insns);
    shadow_frame.SetDexPC(dex_pc);
    instrumentation->DexPcMovedEvent(self, this_object_ref.get(),
                                     shadow_frame.GetMethod(), dex_pc);
    const bool kTracing = false;
    if (kTracing) {
#define TRACE_LOG std::cerr
      TRACE_LOG << PrettyMethod(shadow_frame.GetMethod())
                << StringPrintf("\n0x%x: ", dex_pc)
                << inst->DumpString(&mh.GetDexFile()) << "\n";
      for (size_t i = 0; i < shadow_frame.NumberOfVRegs(); ++i) {
        uint32_t raw_value = shadow_frame.GetVReg(i);
        Object* ref_value = shadow_frame.GetVRegReference(i);
        TRACE_LOG << StringPrintf(" vreg%d=0x%08X", i, raw_value);
        if (ref_value != NULL) {
          if (ref_value->GetClass()->IsStringClass() &&
              ref_value->AsString()->GetCharArray() != NULL) {
            TRACE_LOG << "/java.lang.String \"" << ref_value->AsString()->ToModifiedUtf8() << "\"";
          } else {
            TRACE_LOG << "/" << PrettyTypeOf(ref_value);
          }
        }
      }
      TRACE_LOG << "\n";
#undef TRACE_LOG
    }
    const Instruction* next_inst = inst->Next();
    switch (inst->Opcode()) {
      case Instruction::NOP:
        break;
      case Instruction::MOVE:
        shadow_frame.SetVReg(inst->VRegA_12x(),
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::MOVE_FROM16:
        shadow_frame.SetVReg(inst->VRegA_22x(),
                             shadow_frame.GetVReg(inst->VRegB_22x()));
        break;
      case Instruction::MOVE_16:
        shadow_frame.SetVReg(inst->VRegA_32x(),
                             shadow_frame.GetVReg(inst->VRegB_32x()));
        break;
      case Instruction::MOVE_WIDE:
        shadow_frame.SetVRegLong(inst->VRegA_12x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::MOVE_WIDE_FROM16:
        shadow_frame.SetVRegLong(inst->VRegA_22x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_22x()));
        break;
      case Instruction::MOVE_WIDE_16:
        shadow_frame.SetVRegLong(inst->VRegA_32x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_32x()));
        break;
      case Instruction::MOVE_OBJECT:
        shadow_frame.SetVRegReference(inst->VRegA_12x(),
                                      shadow_frame.GetVRegReference(inst->VRegB_12x()));
        break;
      case Instruction::MOVE_OBJECT_FROM16:
        shadow_frame.SetVRegReference(inst->VRegA_22x(),
                                      shadow_frame.GetVRegReference(inst->VRegB_22x()));
        break;
      case Instruction::MOVE_OBJECT_16:
        shadow_frame.SetVRegReference(inst->VRegA_32x(),
                                      shadow_frame.GetVRegReference(inst->VRegB_32x()));
        break;
      case Instruction::MOVE_RESULT:
        shadow_frame.SetVReg(inst->VRegA_11x(), result_register.GetI());
        break;
      case Instruction::MOVE_RESULT_WIDE:
        shadow_frame.SetVRegLong(inst->VRegA_11x(), result_register.GetJ());
        break;
      case Instruction::MOVE_RESULT_OBJECT:
        shadow_frame.SetVRegReference(inst->VRegA_11x(), result_register.GetL());
        break;
      case Instruction::MOVE_EXCEPTION: {
        Throwable* exception = self->GetException(NULL);
        self->ClearException();
        shadow_frame.SetVRegReference(inst->VRegA_11x(), exception);
        break;
      }
      case Instruction::RETURN_VOID: {
        JValue result;
        instrumentation->MethodExitEvent(self, this_object_ref.get(),
                                         shadow_frame.GetMethod(), dex_pc, result);
        return result;
      }
      case Instruction::RETURN: {
        JValue result;
        result.SetJ(0);
        result.SetI(shadow_frame.GetVReg(inst->VRegA_11x()));
        instrumentation->MethodExitEvent(self, this_object_ref.get(),
                                         shadow_frame.GetMethod(), dex_pc, result);
        return result;
      }
      case Instruction::RETURN_WIDE: {
        JValue result;
        result.SetJ(shadow_frame.GetVRegLong(inst->VRegA_11x()));
        instrumentation->MethodExitEvent(self, this_object_ref.get(),
                                         shadow_frame.GetMethod(), dex_pc, result);
        return result;
      }
      case Instruction::RETURN_OBJECT: {
        JValue result;
        result.SetJ(0);
        result.SetL(shadow_frame.GetVRegReference(inst->VRegA_11x()));
        instrumentation->MethodExitEvent(self, this_object_ref.get(),
                                         shadow_frame.GetMethod(), dex_pc, result);
        return result;
      }
      case Instruction::CONST_4: {
        uint32_t dst = inst->VRegA_11n();
        int32_t val = static_cast<int32_t>(inst->VRegB_11n() << 28) >> 28;
        shadow_frame.SetVReg(dst, val);
        if (val == 0) {
          shadow_frame.SetVRegReference(dst, NULL);
        }
        break;
      }
      case Instruction::CONST_16: {
        uint32_t dst = inst->VRegA_21s();
        int32_t val = static_cast<int16_t>(inst->VRegB_21s());
        shadow_frame.SetVReg(dst, val);
        if (val == 0) {
          shadow_frame.SetVRegReference(dst, NULL);
        }
        break;
      }
      case Instruction::CONST: {
        uint32_t dst = inst->VRegA_31i();
        int32_t val = inst->VRegB_31i();
        shadow_frame.SetVReg(dst, val);
        if (val == 0) {
          shadow_frame.SetVRegReference(dst, NULL);
        }
        break;
      }
      case Instruction::CONST_HIGH16: {
        uint32_t dst = inst->VRegA_21h();
        int32_t val = inst->VRegB_21h() << 16;
        shadow_frame.SetVReg(dst, val);
        if (val == 0) {
          shadow_frame.SetVRegReference(dst, NULL);
        }
        break;
      }
      case Instruction::CONST_WIDE_16:
        shadow_frame.SetVRegLong(inst->VRegA_21s(),
                                 static_cast<int16_t>(inst->VRegB_21s()));
        break;
      case Instruction::CONST_WIDE_32:
        shadow_frame.SetVRegLong(inst->VRegA_31i(),
                                 static_cast<int32_t>(inst->VRegB_31i()));
        break;
      case Instruction::CONST_WIDE:
        shadow_frame.SetVRegLong(inst->VRegA_51l(), inst->VRegB_51l());
        break;
      case Instruction::CONST_WIDE_HIGH16:
        shadow_frame.SetVRegLong(inst->VRegA_21h(),
                                 static_cast<uint64_t>(inst->VRegB_21h()) << 48);
        break;
      case Instruction::CONST_STRING: {
        String* s = ResolveString(self, mh,  inst->VRegB_21c());
        if (UNLIKELY(s == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          shadow_frame.SetVRegReference( inst->VRegA_21c(), s);
        }
        break;
      }
      case Instruction::CONST_STRING_JUMBO: {
        String* s = ResolveString(self, mh,  inst->VRegB_31c());
        if (UNLIKELY(s == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          shadow_frame.SetVRegReference( inst->VRegA_31c(), s);
        }
        break;
      }
      case Instruction::CONST_CLASS: {
        Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(),
                                          self, false, true);
        if (UNLIKELY(c == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          shadow_frame.SetVRegReference(inst->VRegA_21c(), c);
        }
        break;
      }
      case Instruction::MONITOR_ENTER: {
        Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x());
        if (UNLIKELY(obj == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
        } else {
          DoMonitorEnter(self, obj);
        }
        break;
      }
      case Instruction::MONITOR_EXIT: {
        Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x());
        if (UNLIKELY(obj == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
        } else {
          DoMonitorExit(self, obj);
        }
        break;
      }
      case Instruction::CHECK_CAST: {
        Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(),
                                          self, false, true);
        if (UNLIKELY(c == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          Object* obj = shadow_frame.GetVRegReference(inst->VRegA_21c());
          if (UNLIKELY(obj != NULL && !obj->InstanceOf(c))) {
            ThrowClassCastException(c, obj->GetClass());
          }
        }
        break;
      }
      case Instruction::INSTANCE_OF: {
        Class* c = ResolveVerifyAndClinit(inst->VRegC_22c(), shadow_frame.GetMethod(),
                                          self, false, true);
        if (UNLIKELY(c == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c());
          shadow_frame.SetVReg(inst->VRegA_22c(), (obj != NULL && obj->InstanceOf(c)) ? 1 : 0);
        }
        break;
      }
      case Instruction::ARRAY_LENGTH:  {
        Object* array = shadow_frame.GetVRegReference(inst->VRegB_12x());
        if (UNLIKELY(array == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        shadow_frame.SetVReg(inst->VRegA_12x(), array->AsArray()->GetLength());
        break;
      }
      case Instruction::NEW_INSTANCE: {
        Object* obj = AllocObjectFromCode(inst->VRegB_21c(), shadow_frame.GetMethod(),
                                          self, true);
        if (UNLIKELY(obj == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          shadow_frame.SetVRegReference(inst->VRegA_21c(), obj);
        }
        break;
      }
      case Instruction::NEW_ARRAY: {
        int32_t length = shadow_frame.GetVReg(inst->VRegB_22c());
        Object* obj = AllocArrayFromCode(inst->VRegC_22c(), shadow_frame.GetMethod(),
                                         length, self, true);
        if (UNLIKELY(obj == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          shadow_frame.SetVRegReference(inst->VRegA_22c(), obj);
        }
        break;
      }
      case Instruction::FILLED_NEW_ARRAY: {
        const int32_t length = inst->VRegA_35c();
        CHECK(length <= 5);
        if (UNLIKELY(length < 0)) {
          ThrowNegativeArraySizeException(length);
          break;
        }
        Class* arrayClass = ResolveVerifyAndClinit(inst->VRegB_35c(), shadow_frame.GetMethod(),
                                                   self, false, true);
        if (UNLIKELY(arrayClass == NULL)) {
          CHECK(self->IsExceptionPending());
          break;
        }
        CHECK(arrayClass->IsArrayClass());
        Class* componentClass = arrayClass->GetComponentType();
        if (UNLIKELY(componentClass->IsPrimitive() && !componentClass->IsPrimitiveInt())) {
          if (componentClass->IsPrimitiveLong() || componentClass->IsPrimitiveDouble()) {
            ThrowRuntimeException("Bad filled array request for type %s",
                                  PrettyDescriptor(componentClass).c_str());
          } else {
            self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(),
                                     "Ljava/lang/InternalError;",
                                     "Found type %s; filled-new-array not implemented for anything but \'int\'",
                                     PrettyDescriptor(componentClass).c_str());
          }
          break;
        }
        Object* newArray = Array::Alloc(self, arrayClass, length);
        if (UNLIKELY(newArray == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          uint32_t arg[5];
          inst->GetArgs(arg);
          const bool is_primitive_int_component = componentClass->IsPrimitiveInt();
          for (int32_t i = 0; i < length; ++i) {
            if (is_primitive_int_component) {
              newArray->AsIntArray()->Set(i, shadow_frame.GetVReg(arg[i]));
            } else {
              newArray->AsObjectArray<Object>()->Set(i, shadow_frame.GetVRegReference(arg[i]));
            }
          }
        }
        result_register.SetL(newArray);
        break;
      }
      case Instruction::FILLED_NEW_ARRAY_RANGE: {
        int32_t length = inst->VRegA_3rc();
        if (UNLIKELY(length < 0)) {
          ThrowNegativeArraySizeException(length);
          break;
        }
        Class* arrayClass = ResolveVerifyAndClinit(inst->VRegB_3rc(), shadow_frame.GetMethod(),
                                                   self, false, true);
        if (UNLIKELY(arrayClass == NULL)) {
          CHECK(self->IsExceptionPending());
          break;
        }
        CHECK(arrayClass->IsArrayClass());
        Class* componentClass = arrayClass->GetComponentType();
        if (UNLIKELY(componentClass->IsPrimitive() && !componentClass->IsPrimitiveInt())) {
          if (componentClass->IsPrimitiveLong() || componentClass->IsPrimitiveDouble()) {
            ThrowRuntimeException("Bad filled array request for type %s",
                                  PrettyDescriptor(componentClass).c_str());
          } else {
            self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(),
                                     "Ljava/lang/InternalError;",
                                     "Found type %s; filled-new-array not implemented for anything but \'int\'",
                                     PrettyDescriptor(componentClass).c_str());
          }
          break;
        }
        Object* newArray = Array::Alloc(self, arrayClass, length);
        if (UNLIKELY(newArray == NULL)) {
          CHECK(self->IsExceptionPending());
        } else {
          uint32_t vregC = inst->VRegC_3rc();
          const bool is_primitive_int_component = componentClass->IsPrimitiveInt();
          for (int32_t i = 0; i < length; ++i) {
            if (is_primitive_int_component) {
              newArray->AsIntArray()->Set(i, shadow_frame.GetVReg(vregC + i));
            } else {
              newArray->AsObjectArray<Object>()->Set(i, shadow_frame.GetVRegReference(vregC + i));
            }
          }
        }
        result_register.SetL(newArray);
        break;
      }
      case Instruction::FILL_ARRAY_DATA: {
        Object* obj = shadow_frame.GetVRegReference(inst->VRegA_31t());
        if (UNLIKELY(obj == NULL)) {
          ThrowNullPointerException(NULL, "null array in FILL_ARRAY_DATA");
          break;
        }
        Array* array = obj->AsArray();
        DCHECK(array->IsArrayInstance() && !array->IsObjectArray());
        const Instruction::ArrayDataPayload* payload =
            reinterpret_cast<const Instruction::ArrayDataPayload*>(insns + dex_pc + inst->VRegB_31t());
        if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) {
          self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(),
                                   "Ljava/lang/ArrayIndexOutOfBoundsException;",
                                   "failed FILL_ARRAY_DATA; length=%d, index=%d",
                                   array->GetLength(), payload->element_count);
          break;
        }
        uint32_t size_in_bytes = payload->element_count * payload->element_width;
        memcpy(array->GetRawData(payload->element_width), payload->data, size_in_bytes);
        break;
      }
      case Instruction::THROW: {
        Object* exception = shadow_frame.GetVRegReference(inst->VRegA_11x());
        if (UNLIKELY(exception == NULL)) {
          ThrowNullPointerException(NULL, "throw with null exception");
        } else {
          self->SetException(shadow_frame.GetCurrentLocationForThrow(), exception->AsThrowable());
        }
        break;
      }
      case Instruction::GOTO: {
        next_inst = Instruction::At(insns + dex_pc + inst->VRegA_10t());
        break;
      }
      case Instruction::GOTO_16: {
        next_inst = Instruction::At(insns + dex_pc + inst->VRegA_20t());
        break;
      }
      case Instruction::GOTO_32: {
        next_inst = Instruction::At(insns + dex_pc + inst->VRegA_30t());
        break;
      }
      case Instruction::PACKED_SWITCH: {
        const uint16_t* switch_data = insns + dex_pc + inst->VRegB_31t();
        int32_t test_val = shadow_frame.GetVReg(inst->VRegA_31t());
        CHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kPackedSwitchSignature));
        uint16_t size = switch_data[1];
        CHECK_GT(size, 0);
        const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
        CHECK(IsAligned<4>(keys));
        int32_t first_key = keys[0];
        const int32_t* targets = reinterpret_cast<const int32_t*>(&switch_data[4]);
        CHECK(IsAligned<4>(targets));
        int32_t index = test_val - first_key;
        if (index >= 0 && index < size) {
          next_inst = Instruction::At(insns + dex_pc + targets[index]);
        }
        break;
      }
      case Instruction::SPARSE_SWITCH: {
        const uint16_t* switch_data = insns + dex_pc + inst->VRegB_31t();
        int32_t test_val = shadow_frame.GetVReg(inst->VRegA_31t());
        CHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kSparseSwitchSignature));
        uint16_t size = switch_data[1];
        CHECK_GT(size, 0);
        const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
        CHECK(IsAligned<4>(keys));
        const int32_t* entries = keys + size;
        CHECK(IsAligned<4>(entries));
        int lo = 0;
        int hi = size - 1;
        while (lo <= hi) {
          int mid = (lo + hi) / 2;
          int32_t foundVal = keys[mid];
          if (test_val < foundVal) {
            hi = mid - 1;
          } else if (test_val > foundVal) {
            lo = mid + 1;
          } else {
            next_inst = Instruction::At(insns + dex_pc + entries[mid]);
            break;
          }
        }
        break;
      }
      case Instruction::CMPL_FLOAT: {
        float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x());
        float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x());
        int32_t result;
        // TODO: we should not test float equality like this. Reorder comparisons
        // or use a different comparison mechanism.
        if (val1 == val2) {
          result = 0;
        } else if (val1 > val2) {
          result = 1;
        } else {
          result = -1;
        }
        shadow_frame.SetVReg(inst->VRegA_23x(), result);
        break;
      }
      case Instruction::CMPG_FLOAT: {
        float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x());
        float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x());
        int32_t result;
        // TODO: we should not test float equality like this. Reorder comparisons
        // or use a different comparison mechanism.
        if (val1 == val2) {
          result = 0;
        } else if (val1 < val2) {
          result = -1;
        } else {
          result = 1;
        }
        shadow_frame.SetVReg(inst->VRegA_23x(), result);
        break;
      }
      case Instruction::CMPL_DOUBLE: {
        double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x());
        double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x());
        int32_t result;
        // TODO: we should not test double equality like this. Reorder comparisons
        // or use a different comparison mechanism.
        if (val1 == val2) {
          result = 0;
        } else if (val1 > val2) {
          result = 1;
        } else {
          result = -1;
        }
        shadow_frame.SetVReg(inst->VRegA_23x(), result);
        break;
      }

      case Instruction::CMPG_DOUBLE: {
        double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x());
        double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x());
        int32_t result;
        // TODO: we should not test double equality like this. Reorder comparisons
        // or use a different comparison mechanism.
        if (val1 == val2) {
          result = 0;
        } else if (val1 < val2) {
          result = -1;
        } else {
          result = 1;
        }
        shadow_frame.SetVReg(inst->VRegA_23x(), result);
        break;
      }
      case Instruction::CMP_LONG: {
        int64_t val1 = shadow_frame.GetVRegLong(inst->VRegB_23x());
        int64_t val2 = shadow_frame.GetVRegLong(inst->VRegC_23x());
        int32_t result;
        if (val1 > val2) {
          result = 1;
        } else if (val1 == val2) {
          result = 0;
        } else {
          result = -1;
        }
        shadow_frame.SetVReg(inst->VRegA_23x(), result);
        break;
      }
      case Instruction::IF_EQ: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) == shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_NE: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) != shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_LT: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) < shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_GE: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) >= shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_GT: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) > shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_LE: {
        if (shadow_frame.GetVReg(inst->VRegA_22t()) <= shadow_frame.GetVReg(inst->VRegB_22t())) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegC_22t());
        }
        break;
      }
      case Instruction::IF_EQZ: {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) == 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::IF_NEZ: {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) != 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::IF_LTZ: {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) < 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::IF_GEZ: {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) >= 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::IF_GTZ: {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) > 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::IF_LEZ:  {
        if (shadow_frame.GetVReg(inst->VRegA_21t()) <= 0) {
          next_inst = Instruction::At(insns + dex_pc + inst->VRegB_21t());
        }
        break;
      }
      case Instruction::AGET_BOOLEAN: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVReg(inst->VRegA_23x(), a->AsBooleanArray()->Get(index));
        break;
      }
      case Instruction::AGET_BYTE: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVReg(inst->VRegA_23x(), a->AsByteArray()->Get(index));
        break;
      }
      case Instruction::AGET_CHAR: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVReg(inst->VRegA_23x(), a->AsCharArray()->Get(index));
        break;
      }
      case Instruction::AGET_SHORT: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVReg(inst->VRegA_23x(), a->AsShortArray()->Get(index));
        break;
      }
      case Instruction::AGET: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVReg(inst->VRegA_23x(), a->AsIntArray()->Get(index));
        break;
      }
      case Instruction::AGET_WIDE:  {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVRegLong(inst->VRegA_23x(), a->AsLongArray()->Get(index));
        break;
      }
      case Instruction::AGET_OBJECT: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        shadow_frame.SetVRegReference(inst->VRegA_23x(), a->AsObjectArray<Object>()->Get(index));
        break;
      }
      case Instruction::APUT_BOOLEAN: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        uint8_t val = shadow_frame.GetVReg(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsBooleanArray()->Set(index, val);
        break;
      }
      case Instruction::APUT_BYTE: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int8_t val = shadow_frame.GetVReg(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsByteArray()->Set(index, val);
        break;
      }
      case Instruction::APUT_CHAR: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        uint16_t val = shadow_frame.GetVReg(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsCharArray()->Set(index, val);
        break;
      }
      case Instruction::APUT_SHORT: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int16_t val = shadow_frame.GetVReg(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsShortArray()->Set(index, val);
        break;
      }
      case Instruction::APUT: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int32_t val = shadow_frame.GetVReg(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsIntArray()->Set(index, val);
        break;
      }
      case Instruction::APUT_WIDE: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        int64_t val = shadow_frame.GetVRegLong(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsLongArray()->Set(index, val);
        break;
      }
      case Instruction::APUT_OBJECT: {
        Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
        if (UNLIKELY(a == NULL)) {
          ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
          break;
        }
        Object* val = shadow_frame.GetVRegReference(inst->VRegA_23x());
        int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
        a->AsObjectArray<Object>()->Set(index, val);
        break;
      }
      case Instruction::IGET_BOOLEAN:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimBoolean);
        break;
      case Instruction::IGET_BYTE:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimByte);
        break;
      case Instruction::IGET_CHAR:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimChar);
        break;
      case Instruction::IGET_SHORT:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimShort);
        break;
      case Instruction::IGET:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimInt);
        break;
      case Instruction::IGET_WIDE:
        DoFieldGet(self, shadow_frame, inst, InstancePrimitiveRead, Primitive::kPrimLong);
        break;
      case Instruction::IGET_OBJECT:
        DoFieldGet(self, shadow_frame, inst, InstanceObjectRead, Primitive::kPrimNot);
        break;
      case Instruction::SGET_BOOLEAN:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimBoolean);
        break;
      case Instruction::SGET_BYTE:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimByte);
        break;
      case Instruction::SGET_CHAR:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimChar);
        break;
      case Instruction::SGET_SHORT:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimShort);
        break;
      case Instruction::SGET:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimInt);
        break;
      case Instruction::SGET_WIDE:
        DoFieldGet(self, shadow_frame, inst, StaticPrimitiveRead, Primitive::kPrimLong);
        break;
      case Instruction::SGET_OBJECT:
        DoFieldGet(self, shadow_frame, inst, StaticObjectRead, Primitive::kPrimNot);
        break;
      case Instruction::IPUT_BOOLEAN:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimBoolean);
        break;
      case Instruction::IPUT_BYTE:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimByte);
        break;
      case Instruction::IPUT_CHAR:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimChar);
        break;
      case Instruction::IPUT_SHORT:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimShort);
        break;
      case Instruction::IPUT:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimInt);
        break;
      case Instruction::IPUT_WIDE:
        DoFieldPut(self, shadow_frame, inst, InstancePrimitiveWrite, Primitive::kPrimLong);
        break;
      case Instruction::IPUT_OBJECT:
        DoFieldPut(self, shadow_frame, inst, InstanceObjectWrite, Primitive::kPrimNot);
        break;
      case Instruction::SPUT_BOOLEAN:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimBoolean);
        break;
      case Instruction::SPUT_BYTE:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimByte);
        break;
      case Instruction::SPUT_CHAR:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimChar);
        break;
      case Instruction::SPUT_SHORT:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimShort);
        break;
      case Instruction::SPUT:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimInt);
        break;
      case Instruction::SPUT_WIDE:
        DoFieldPut(self, shadow_frame, inst, StaticPrimitiveWrite, Primitive::kPrimLong);
        break;
      case Instruction::SPUT_OBJECT:
        DoFieldPut(self, shadow_frame, inst, StaticObjectWrite, Primitive::kPrimNot);
        break;
      case Instruction::INVOKE_VIRTUAL:
        DoInvoke(self, mh, shadow_frame, inst, kVirtual, false, &result_register);
        break;
      case Instruction::INVOKE_VIRTUAL_RANGE:
        DoInvoke(self, mh, shadow_frame, inst, kVirtual, true, &result_register);
        break;
      case Instruction::INVOKE_SUPER:
        DoInvoke(self, mh, shadow_frame, inst, kSuper, false, &result_register);
        break;
      case Instruction::INVOKE_SUPER_RANGE:
        DoInvoke(self, mh, shadow_frame, inst, kSuper, true, &result_register);
        break;
      case Instruction::INVOKE_DIRECT:
        DoInvoke(self, mh, shadow_frame, inst, kDirect, false, &result_register);
        break;
      case Instruction::INVOKE_DIRECT_RANGE:
        DoInvoke(self, mh, shadow_frame, inst, kDirect, true, &result_register);
        break;
      case Instruction::INVOKE_INTERFACE:
        DoInvoke(self, mh, shadow_frame, inst, kInterface, false, &result_register);
        break;
      case Instruction::INVOKE_INTERFACE_RANGE:
        DoInvoke(self, mh, shadow_frame, inst, kInterface, true, &result_register);
        break;
      case Instruction::INVOKE_STATIC:
        DoInvoke(self, mh, shadow_frame, inst, kStatic, false, &result_register);
        break;
      case Instruction::INVOKE_STATIC_RANGE:
        DoInvoke(self, mh, shadow_frame, inst, kStatic, true, &result_register);
        break;
      case Instruction::NEG_INT:
        shadow_frame.SetVReg(inst->VRegA_12x(), -shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::NOT_INT:
        shadow_frame.SetVReg(inst->VRegA_12x(), ~shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::NEG_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_12x(), -shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::NOT_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_12x(), ~shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::NEG_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_12x(), -shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      case Instruction::NEG_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_12x(), -shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      case Instruction::INT_TO_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_12x(), shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::INT_TO_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_12x(), shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::INT_TO_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_12x(), shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      case Instruction::LONG_TO_INT:
        shadow_frame.SetVReg(inst->VRegA_12x(), shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::LONG_TO_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_12x(), shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::LONG_TO_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_12x(), shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      case Instruction::FLOAT_TO_INT: {
        uint32_t dst = inst->VRegA_12x();
        float val = shadow_frame.GetVRegFloat(inst->VRegB_12x());
        if (val != val) {
          shadow_frame.SetVReg(dst, 0);
        } else if (val > static_cast<float>(kMaxInt)) {
          shadow_frame.SetVReg(dst, kMaxInt);
        } else if (val < static_cast<float>(kMinInt)) {
          shadow_frame.SetVReg(dst, kMinInt);
        } else {
          shadow_frame.SetVReg(dst, val);
        }
        break;
      }
      case Instruction::FLOAT_TO_LONG: {
        uint32_t dst = inst->VRegA_12x();
        float val = shadow_frame.GetVRegFloat(inst->VRegB_12x());
        if (val != val) {
          shadow_frame.SetVRegLong(dst, 0);
        } else if (val > static_cast<float>(kMaxLong)) {
          shadow_frame.SetVRegLong(dst, kMaxLong);
        } else if (val < static_cast<float>(kMinLong)) {
          shadow_frame.SetVRegLong(dst, kMinLong);
        } else {
          shadow_frame.SetVRegLong(dst, val);
        }
        break;
      }
      case Instruction::FLOAT_TO_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_12x(), shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      case Instruction::DOUBLE_TO_INT: {
        uint32_t dst = inst->VRegA_12x();
        double val = shadow_frame.GetVRegDouble(inst->VRegB_12x());
        if (val != val) {
          shadow_frame.SetVReg(dst, 0);
        } else if (val > static_cast<double>(kMaxInt)) {
          shadow_frame.SetVReg(dst, kMaxInt);
        } else if (val < static_cast<double>(kMinInt)) {
          shadow_frame.SetVReg(dst, kMinInt);
        } else {
          shadow_frame.SetVReg(dst, val);
        }
        break;
      }
      case Instruction::DOUBLE_TO_LONG: {
        uint32_t dst = inst->VRegA_12x();
        double val = shadow_frame.GetVRegDouble(inst->VRegB_12x());
        if (val != val) {
          shadow_frame.SetVRegLong(dst, 0);
        } else if (val > static_cast<double>(kMaxLong)) {
          shadow_frame.SetVRegLong(dst, kMaxLong);
        } else if (val < static_cast<double>(kMinLong)) {
          shadow_frame.SetVRegLong(dst, kMinLong);
        } else {
          shadow_frame.SetVRegLong(dst, val);
        }
        break;
      }
      case Instruction::DOUBLE_TO_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_12x(), shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      case Instruction::INT_TO_BYTE:
        shadow_frame.SetVReg(inst->VRegA_12x(),
                             static_cast<int8_t>(shadow_frame.GetVReg(inst->VRegB_12x())));
        break;
      case Instruction::INT_TO_CHAR:
        shadow_frame.SetVReg(inst->VRegA_12x(),
                             static_cast<uint16_t>(shadow_frame.GetVReg(inst->VRegB_12x())));
        break;
      case Instruction::INT_TO_SHORT:
        shadow_frame.SetVReg(inst->VRegA_12x(),
                             static_cast<int16_t>(shadow_frame.GetVReg(inst->VRegB_12x())));
        break;
      case Instruction::ADD_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) +
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::SUB_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) -
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::MUL_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) *
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::DIV_INT:
        DoIntDivide(self, shadow_frame, inst->VRegA_23x(),
                    shadow_frame.GetVReg(inst->VRegB_23x()),
                    shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::REM_INT:
        DoIntRemainder(self, shadow_frame, inst->VRegA_23x(),
                       shadow_frame.GetVReg(inst->VRegB_23x()),
                       shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::SHL_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) <<
                             (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
        break;
      case Instruction::SHR_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) >>
                             (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
        break;
      case Instruction::USHR_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_23x())) >>
                             (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
        break;
      case Instruction::AND_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) &
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::OR_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) |
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::XOR_INT:
        shadow_frame.SetVReg(inst->VRegA_23x(),
                             shadow_frame.GetVReg(inst->VRegB_23x()) ^
                             shadow_frame.GetVReg(inst->VRegC_23x()));
        break;
      case Instruction::ADD_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) +
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::SUB_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) -
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::MUL_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) *
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::DIV_LONG:
        DoLongDivide(self, shadow_frame, inst->VRegA_23x(),
                     shadow_frame.GetVRegLong(inst->VRegB_23x()),
                    shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::REM_LONG:
        DoLongRemainder(self, shadow_frame, inst->VRegA_23x(),
                        shadow_frame.GetVRegLong(inst->VRegB_23x()),
                        shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::AND_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) &
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::OR_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) |
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::XOR_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) ^
                                 shadow_frame.GetVRegLong(inst->VRegC_23x()));
        break;
      case Instruction::SHL_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) <<
                                 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
        break;
      case Instruction::SHR_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 shadow_frame.GetVRegLong(inst->VRegB_23x()) >>
                                 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
        break;
      case Instruction::USHR_LONG:
        shadow_frame.SetVRegLong(inst->VRegA_23x(),
                                 static_cast<uint64_t>(shadow_frame.GetVRegLong(inst->VRegB_23x())) >>
                                 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
        break;
      case Instruction::ADD_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_23x(),
                                  shadow_frame.GetVRegFloat(inst->VRegB_23x()) +
                                  shadow_frame.GetVRegFloat(inst->VRegC_23x()));
        break;
      case Instruction::SUB_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_23x(),
                                  shadow_frame.GetVRegFloat(inst->VRegB_23x()) -
                                  shadow_frame.GetVRegFloat(inst->VRegC_23x()));
        break;
      case Instruction::MUL_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_23x(),
                                  shadow_frame.GetVRegFloat(inst->VRegB_23x()) *
                                  shadow_frame.GetVRegFloat(inst->VRegC_23x()));
        break;
      case Instruction::DIV_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_23x(),
                                  shadow_frame.GetVRegFloat(inst->VRegB_23x()) /
                                  shadow_frame.GetVRegFloat(inst->VRegC_23x()));
        break;
      case Instruction::REM_FLOAT:
        shadow_frame.SetVRegFloat(inst->VRegA_23x(),
                                  fmodf(shadow_frame.GetVRegFloat(inst->VRegB_23x()),
                                        shadow_frame.GetVRegFloat(inst->VRegC_23x())));
        break;
      case Instruction::ADD_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_23x(),
                                   shadow_frame.GetVRegDouble(inst->VRegB_23x()) +
                                   shadow_frame.GetVRegDouble(inst->VRegC_23x()));
        break;
      case Instruction::SUB_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_23x(),
                                   shadow_frame.GetVRegDouble(inst->VRegB_23x()) -
                                   shadow_frame.GetVRegDouble(inst->VRegC_23x()));
        break;
      case Instruction::MUL_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_23x(),
                                   shadow_frame.GetVRegDouble(inst->VRegB_23x()) *
                                   shadow_frame.GetVRegDouble(inst->VRegC_23x()));
        break;
      case Instruction::DIV_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_23x(),
                                   shadow_frame.GetVRegDouble(inst->VRegB_23x()) /
                                   shadow_frame.GetVRegDouble(inst->VRegC_23x()));
        break;
      case Instruction::REM_DOUBLE:
        shadow_frame.SetVRegDouble(inst->VRegA_23x(),
                                   fmod(shadow_frame.GetVRegDouble(inst->VRegB_23x()),
                                        shadow_frame.GetVRegDouble(inst->VRegC_23x())));
        break;
      case Instruction::ADD_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) +
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::SUB_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) -
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::MUL_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) *
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::REM_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        DoIntRemainder(self, shadow_frame, vregA, shadow_frame.GetVReg(vregA),
                       shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::SHL_INT_2ADDR:{
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) <<
                             (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x1f));
        break;
      }
      case Instruction::SHR_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) >>
                             (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x1f));
        break;
      }
      case Instruction::USHR_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             static_cast<uint32_t>(shadow_frame.GetVReg(vregA)) >>
                             (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x1f));
        break;
      }
      case Instruction::AND_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) &
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::OR_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) |
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::XOR_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVReg(vregA,
                             shadow_frame.GetVReg(vregA) ^
                             shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::DIV_INT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        DoIntDivide(self, shadow_frame, vregA, shadow_frame.GetVReg(vregA),
                    shadow_frame.GetVReg(inst->VRegB_12x()));
        break;
      }
      case Instruction::ADD_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) +
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::SUB_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) -
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::MUL_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) *
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::DIV_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        DoLongDivide(self, shadow_frame, vregA, shadow_frame.GetVRegLong(vregA),
                    shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::REM_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        DoLongRemainder(self, shadow_frame, vregA, shadow_frame.GetVRegLong(vregA),
                        shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::AND_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) &
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::OR_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) |
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::XOR_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) ^
                                 shadow_frame.GetVRegLong(inst->VRegB_12x()));
        break;
      }
      case Instruction::SHL_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) <<
                                 (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x3f));
        break;
      }
      case Instruction::SHR_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 shadow_frame.GetVRegLong(vregA) >>
                                 (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x3f));
        break;
      }
      case Instruction::USHR_LONG_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegLong(vregA,
                                 static_cast<uint64_t>(shadow_frame.GetVRegLong(vregA)) >>
                                 (shadow_frame.GetVReg(inst->VRegB_12x()) & 0x3f));
        break;
      }
      case Instruction::ADD_FLOAT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegFloat(vregA,
                                  shadow_frame.GetVRegFloat(vregA) +
                                  shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      }
      case Instruction::SUB_FLOAT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegFloat(vregA,
                                  shadow_frame.GetVRegFloat(vregA) -
                                  shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      }
      case Instruction::MUL_FLOAT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegFloat(vregA,
                                  shadow_frame.GetVRegFloat(vregA) *
                                  shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      }
      case Instruction::DIV_FLOAT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegFloat(vregA,
                                  shadow_frame.GetVRegFloat(vregA) /
                                  shadow_frame.GetVRegFloat(inst->VRegB_12x()));
        break;
      }
      case Instruction::REM_FLOAT_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegFloat(vregA,
                                  fmodf(shadow_frame.GetVRegFloat(vregA),
                                        shadow_frame.GetVRegFloat(inst->VRegB_12x())));
        break;
      }
      case Instruction::ADD_DOUBLE_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegDouble(vregA,
                                   shadow_frame.GetVRegDouble(vregA) +
                                   shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      }
      case Instruction::SUB_DOUBLE_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegDouble(vregA,
                                   shadow_frame.GetVRegDouble(vregA) -
                                   shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      }
      case Instruction::MUL_DOUBLE_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegDouble(vregA,
                                   shadow_frame.GetVRegDouble(vregA) *
                                   shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      }
      case Instruction::DIV_DOUBLE_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegDouble(vregA,
                                   shadow_frame.GetVRegDouble(vregA) /
                                   shadow_frame.GetVRegDouble(inst->VRegB_12x()));
        break;
      }
      case Instruction::REM_DOUBLE_2ADDR: {
        uint32_t vregA = inst->VRegA_12x();
        shadow_frame.SetVRegDouble(vregA,
                                   fmod(shadow_frame.GetVRegDouble(vregA),
                                        shadow_frame.GetVRegDouble(inst->VRegB_12x())));
        break;
      }
      case Instruction::ADD_INT_LIT16:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             shadow_frame.GetVReg(inst->VRegB_22s()) +
                             inst->VRegC_22s());
        break;
      case Instruction::RSUB_INT:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             inst->VRegC_22s() -
                             shadow_frame.GetVReg(inst->VRegB_22s()));
        break;
      case Instruction::MUL_INT_LIT16:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             shadow_frame.GetVReg(inst->VRegB_22s()) *
                             inst->VRegC_22s());
        break;
      case Instruction::DIV_INT_LIT16:
        DoIntDivide(self, shadow_frame, inst->VRegA_22s(),
                    shadow_frame.GetVReg(inst->VRegB_22s()), inst->VRegC_22s());
        break;
      case Instruction::REM_INT_LIT16:
        DoIntRemainder(self, shadow_frame, inst->VRegA_22s(),
                       shadow_frame.GetVReg(inst->VRegB_22s()), inst->VRegC_22s());
        break;
      case Instruction::AND_INT_LIT16:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             shadow_frame.GetVReg(inst->VRegB_22s()) &
                             inst->VRegC_22s());
        break;
      case Instruction::OR_INT_LIT16:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             shadow_frame.GetVReg(inst->VRegB_22s()) |
                             inst->VRegC_22s());
        break;
      case Instruction::XOR_INT_LIT16:
        shadow_frame.SetVReg(inst->VRegA_22s(),
                             shadow_frame.GetVReg(inst->VRegB_22s()) ^
                             inst->VRegC_22s());
        break;
      case Instruction::ADD_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) +
                             inst->VRegC_22b());
        break;
      case Instruction::RSUB_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             inst->VRegC_22b() -
                             shadow_frame.GetVReg(inst->VRegB_22b()));
        break;
      case Instruction::MUL_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) *
                             inst->VRegC_22b());
        break;
      case Instruction::DIV_INT_LIT8:
        DoIntDivide(self, shadow_frame, inst->VRegA_22b(),
                    shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b());
        break;
      case Instruction::REM_INT_LIT8:
        DoIntRemainder(self, shadow_frame, inst->VRegA_22b(),
                       shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b());
        break;
      case Instruction::AND_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) &
                             inst->VRegC_22b());
        break;
      case Instruction::OR_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) |
                             inst->VRegC_22b());
        break;
      case Instruction::XOR_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) ^
                             inst->VRegC_22b());
        break;
      case Instruction::SHL_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) <<
                             (inst->VRegC_22b() & 0x1f));
        break;
      case Instruction::SHR_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             shadow_frame.GetVReg(inst->VRegB_22b()) >>
                             (inst->VRegC_22b() & 0x1f));
        break;
      case Instruction::USHR_INT_LIT8:
        shadow_frame.SetVReg(inst->VRegA_22b(),
                             static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_22b())) >>
                             (inst->VRegC_22b() & 0x1f));
        break;
      default:
        LOG(FATAL) << "Unexpected instruction: " << inst->DumpString(&mh.GetDexFile());
        break;
    }
    if (UNLIKELY(self->IsExceptionPending())) {
      self->VerifyStack();
      ThrowLocation throw_location;
      mirror::Throwable* exception = self->GetException(&throw_location);
      uint32_t found_dex_pc = shadow_frame.GetMethod()->FindCatchBlock(exception->GetClass(), dex_pc);
      if (found_dex_pc == DexFile::kDexNoIndex) {
        JValue result;
        result.SetJ(0);
        instrumentation->MethodUnwindEvent(self, this_object_ref.get(),
                                           shadow_frame.GetMethod(), dex_pc);
        return result;  // Handler in caller.
      } else {
        instrumentation->ExceptionCaughtEvent(self, throw_location,
                                              shadow_frame.GetMethod(),
                                              found_dex_pc, exception);
        next_inst = Instruction::At(insns + found_dex_pc);
      }
    }
    inst = next_inst;
  }
}

void EnterInterpreterFromInvoke(Thread* self, AbstractMethod* method, Object* receiver,
                                uint32_t* args, JValue* result) {
  DCHECK_EQ(self, Thread::Current());
  if (__builtin_frame_address(0) < self->GetStackEnd()) {
    ThrowStackOverflowError(self);
    return;
  }

  MethodHelper mh(method);
  const DexFile::CodeItem* code_item = mh.GetCodeItem();
  uint16_t num_regs;
  uint16_t num_ins;
  if (code_item != NULL) {
    num_regs =  code_item->registers_size_;
    num_ins = code_item->ins_size_;
  } else if (method->IsAbstract()) {
    ThrowLocation throw_location = self->GetCurrentLocationForThrow();
    self->ThrowNewExceptionF(throw_location, "Ljava/lang/AbstractMethodError;",
                             "abstract method \"%s\"", PrettyMethod(method).c_str());
    return;
  } else {
    DCHECK(method->IsNative());
    num_regs = num_ins = AbstractMethod::NumArgRegisters(mh.GetShorty());
    if (!method->IsStatic()) {
      num_regs++;
      num_ins++;
    }
  }
  // Set up shadow frame with matching number of reference slots to vregs.
  ShadowFrame* last_shadow_frame = self->GetManagedStack()->GetTopShadowFrame();
  UniquePtr<ShadowFrame> shadow_frame(ShadowFrame::Create(num_regs,
                                                          last_shadow_frame,
                                                          method, 0));
  self->PushShadowFrame(shadow_frame.get());
  size_t cur_reg = num_regs - num_ins;
  if (!method->IsStatic()) {
    CHECK(receiver != NULL);
    shadow_frame->SetVRegReference(cur_reg, receiver);
    ++cur_reg;
  } else if (UNLIKELY(!method->GetDeclaringClass()->IsInitializing())) {
    ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
    if (UNLIKELY(!class_linker->EnsureInitialized(method->GetDeclaringClass(),
                                                  true, true))) {
      CHECK(self->IsExceptionPending());
      self->PopShadowFrame();
      return;
    }
    CHECK(method->GetDeclaringClass()->IsInitializing());
  }
  const char* shorty = mh.GetShorty();
  for (size_t shorty_pos = 0, arg_pos = 0; cur_reg < num_regs; ++shorty_pos, ++arg_pos, cur_reg++) {
    DCHECK_LT(shorty_pos + 1, mh.GetShortyLength());
    switch (shorty[shorty_pos + 1]) {
      case 'L': {
        Object* o = reinterpret_cast<Object*>(args[arg_pos]);
        shadow_frame->SetVRegReference(cur_reg, o);
        break;
      }
      case 'J': case 'D': {
        uint64_t wide_value = (static_cast<uint64_t>(args[arg_pos + 1]) << 32) | args[arg_pos];
        shadow_frame->SetVRegLong(cur_reg, wide_value);
        cur_reg++;
        arg_pos++;
        break;
      }
      default:
        shadow_frame->SetVReg(cur_reg, args[arg_pos]);
        break;
    }
  }
  if (LIKELY(!method->IsNative())) {
    JValue r = Execute(self, mh, code_item, *shadow_frame.get(), JValue());
    if (result != NULL) {
      *result = r;
    }
  } else {
    // We don't expect to be asked to interpret native code (which is entered via a JNI compiler
    // generated stub) except during testing and image writing.
    if (!Runtime::Current()->IsStarted()) {
      UnstartedRuntimeJni(self, method, receiver, args, result);
    } else {
      InterpreterJni(self, method, shorty, receiver, args, result);
    }
  }
  self->PopShadowFrame();
}

void EnterInterpreterFromDeoptimize(Thread* self, ShadowFrame* shadow_frame, JValue* ret_val)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  JValue value;
  value.SetJ(ret_val->GetJ());  // Set value to last known result in case the shadow frame chain is empty.
  MethodHelper mh;
  while (shadow_frame != NULL) {
    self->SetTopOfShadowStack(shadow_frame);
    mh.ChangeMethod(shadow_frame->GetMethod());
    const DexFile::CodeItem* code_item = mh.GetCodeItem();
    value = Execute(self, mh, code_item, *shadow_frame, value);
    ShadowFrame* old_frame = shadow_frame;
    shadow_frame = shadow_frame->GetLink();
    delete old_frame;
  }
  ret_val->SetJ(value.GetJ());
}

JValue EnterInterpreterFromStub(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
                                ShadowFrame& shadow_frame)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  DCHECK_EQ(self, Thread::Current());
  if (__builtin_frame_address(0) < self->GetStackEnd()) {
    ThrowStackOverflowError(self);
    return JValue();
  }

  return Execute(self, mh, code_item, shadow_frame, JValue());
}

JValue EnterInterpreterFromInterpreter(Thread* self, ShadowFrame* shadow_frame)
    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
  if (__builtin_frame_address(0) < self->GetStackEnd()) {
    ThrowStackOverflowError(self);
    return JValue();
  }

  AbstractMethod* method = shadow_frame->GetMethod();
  if (method->IsStatic() && !method->GetDeclaringClass()->IsInitializing()) {
    if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(method->GetDeclaringClass(),
                                                                 true, true)) {
      DCHECK(Thread::Current()->IsExceptionPending());
      return JValue();
    }
    CHECK(method->GetDeclaringClass()->IsInitializing());
  }

  self->PushShadowFrame(shadow_frame);

  MethodHelper mh(method);
  const DexFile::CodeItem* code_item = mh.GetCodeItem();
  JValue result;
  if (LIKELY(!method->IsNative())) {
    result = Execute(self, mh, code_item, *shadow_frame, JValue());
  } else {
    // We don't expect to be asked to interpret native code (which is entered via a JNI compiler
    // generated stub) except during testing and image writing.
    CHECK(!Runtime::Current()->IsStarted());
    Object* receiver = method->IsStatic() ? NULL : shadow_frame->GetVRegReference(0);
    uint32_t* args = shadow_frame->GetVRegArgs(method->IsStatic() ? 0 : 1);
    UnstartedRuntimeJni(self, method, receiver, args, &result);
  }

  self->PopShadowFrame();
  return result;
}

}  // namespace interpreter
}  // namespace art