Move compiler-specific code out of runtime_support_common.

Helpers or utilities such as FindFieldFast are still in
runtime_support_common. But LLVM has different stacks, no callee-saves
and different exception mechanisms. Those won't belong to
runtime_support_common.

Change-Id: Ibc43d7d53316941481a6a21815ddefdc1e6bdde6

4 files changed, 435 insertions, 344 deletions

diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index 16f9704ce4..013a5302f1 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -204,25 +204,37 @@ Object* art_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
   return CheckAndAllocArrayFromCode(type_idx, referrer, length, Thread::Current(), true);
 }
 
+static Method* FindMethodHelper(uint32_t method_idx, Object* this_object, Method* caller_method,
+                                bool access_check, InvokeType type){
+  Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
+  if (UNLIKELY(method == NULL)) {
+    method = FindMethodFromCode(method_idx, this_object, caller_method,
+                                Thread::Current(), access_check, type);
+    if (UNLIKELY(method == NULL)) {
+      CHECK(Thread::Current()->IsExceptionPending());
+      return 0;  // failure
+    }
+  }
+  DCHECK(!Thread::Current()->IsExceptionPending());
+  return method;
+}
+
 Object* art_find_interface_method_from_code(uint32_t method_idx,
                                             Object* this_object,
                                             Method* referrer) {
-  return _artInvokeCommon(method_idx, this_object, referrer,
-                          Thread::Current(), NULL, true, kInterface);
+  return FindMethodHelper(method_idx, this_object, referrer, true, kInterface);
 }
 
 Object* art_find_virtual_method_from_code(uint32_t method_idx,
                                           Object* this_object,
                                           Method* referrer) {
-  return _artInvokeCommon(method_idx, this_object, referrer,
-                          Thread::Current(), NULL, true, kVirtual);
+  return FindMethodHelper(method_idx, this_object, referrer, true, kVirtual);
 }
 
 Object* art_find_super_method_from_code(uint32_t method_idx,
                                         Object* this_object,
                                         Method* referrer) {
-  return _artInvokeCommon(method_idx, this_object, referrer,
-                          Thread::Current(), NULL, true, kSuper);
+  return FindMethodHelper(method_idx, this_object, referrer, true, kSuper);
 }
 
 Object* art_initialize_static_storage_from_code(uint32_t type_idx, Method* referrer) {
@@ -244,54 +256,174 @@ Object* art_resolve_string_from_code(Method* referrer, uint32_t string_idx) {
 }
 
 int32_t art_set32_static_from_code(uint32_t field_idx, Method* referrer, int32_t new_value) {
-  return artSet32StaticFromCode(field_idx, new_value, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(NULL, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, true, true, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(NULL, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_set64_static_from_code(uint32_t field_idx, Method* referrer, int64_t new_value) {
-  return artSet64StaticFromCode(field_idx, referrer, new_value, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(NULL, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, true, true, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(NULL, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_set_obj_static_from_code(uint32_t field_idx, Method* referrer, Object* new_value) {
-  return artSetObjStaticFromCode(field_idx, new_value, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    field->SetObj(NULL, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    field->SetObj(NULL, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_get32_static_from_code(uint32_t field_idx, Method* referrer) {
-  return artGet32StaticFromCode(field_idx, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(NULL);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, true, false, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(NULL);
+  }
+  return 0;
 }
 
 int64_t art_get64_static_from_code(uint32_t field_idx, Method* referrer) {
-  return artGet64StaticFromCode(field_idx, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(NULL);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, true, false, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(NULL);
+  }
+  return 0;
 }
 
 Object* art_get_obj_static_from_code(uint32_t field_idx, Method* referrer) {
-  return artGetObjStaticFromCode(field_idx, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(NULL);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            true, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(NULL);
+  }
+  return 0;
 }
 
 int32_t art_set32_instance_from_code(uint32_t field_idx, Method* referrer,
                                      Object* obj, uint32_t new_value) {
-  return artSet32InstanceFromCode(field_idx, obj, new_value, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(obj, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, true, true, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(obj, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_set64_instance_from_code(uint32_t field_idx, Method* referrer,
                                      Object* obj, int64_t new_value) {
-  return artSet64InstanceFromCode(field_idx, obj, new_value, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(obj, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, true, true, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(obj, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_set_obj_instance_from_code(uint32_t field_idx, Method* referrer,
                                        Object* obj, Object* new_value) {
-  return artSetObjInstanceFromCode(field_idx, obj, new_value, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    field->SetObj(obj, new_value);
+    return 0;
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    field->SetObj(obj, new_value);
+    return 0;
+  }
+  return -1;
 }
 
 int32_t art_get32_instance_from_code(uint32_t field_idx, Method* referrer, Object* obj) {
-  return artGet32InstanceFromCode(field_idx, obj, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(obj);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, true, false, sizeof(uint32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(obj);
+  }
+  return 0;
 }
 
 int64_t art_get64_instance_from_code(uint32_t field_idx, Method* referrer, Object* obj) {
-  return artGet64InstanceFromCode(field_idx, obj, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(obj);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, true, false, sizeof(uint64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(obj);
+  }
+  return 0;
 }
 
 Object* art_get_obj_instance_from_code(uint32_t field_idx, Method* referrer, Object* obj) {
-  return artGetObjInstanceFromCode(field_idx, obj, referrer, Thread::Current(), NULL);
+  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(obj);
+  }
+  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
+                            false, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(obj);
+  }
+  return 0;
 }
 
 
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index 9854151b9d..6531eb21f0 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -29,6 +29,57 @@
 
 namespace art {
 
+extern "C" int art_cmpl_float(float a, float b) {
+    if (a == b) {
+        return 0;
+    } else if (a < b) {
+        return -1;
+    } else if (a > b) {
+        return 1;
+    }
+    return -1;
+}
+
+extern "C" int art_cmpg_float(float a, float b) {
+    if (a == b) {
+        return 0;
+    } else if (a < b) {
+        return -1;
+    } else if (a > b) {
+        return 1;
+    }
+    return 1;
+}
+
+extern "C" int art_cmpl_double(double a, double b) {
+    if (a == b) {
+        return 0;
+    } else if (a < b) {
+        return -1;
+    } else if (a > b) {
+        return 1;
+    }
+    return -1;
+}
+
+extern "C" int art_cmpg_double(double a, double b) {
+    if (a == b) {
+        return 0;
+    } else if (a < b) {
+        return -1;
+    } else if (a > b) {
+        return 1;
+    }
+    return 1;
+}
+
+// Place a special frame at the TOS that will save the callee saves for the given type
+static void  FinishCalleeSaveFrameSetup(Thread* self, Method** sp, Runtime::CalleeSaveType type) {
+  // Be aware the store below may well stomp on an incoming argument
+  *sp = Runtime::Current()->GetCalleeSaveMethod(type);
+  self->SetTopOfStack(sp, 0);
+}
+
 /*
  * Report location to debugger.  Note: dex_pc is the current offset within
  * the method.  However, because the offset alone cannot distinguish between
@@ -529,6 +580,216 @@ extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp) {
   return code;
 }
 
+
+extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
+                                           Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(NULL);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get32(NULL);
+  }
+  return 0;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
+                                           Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(NULL);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    return field->Get64(NULL);
+  }
+  return 0;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
+                                           Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(NULL);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    return field->GetObj(NULL);
+  }
+  return NULL;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
+                                             const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
+  if (LIKELY(field != NULL && obj != NULL)) {
+    return field->Get32(obj);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+    } else {
+      return field->Get32(obj);
+    }
+  }
+  return 0;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
+                                             const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
+  if (LIKELY(field != NULL && obj != NULL)) {
+    return field->Get64(obj);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+    } else {
+      return field->Get64(obj);
+    }
+  }
+  return 0;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
+                                              const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL && obj != NULL)) {
+    return field->GetObj(obj);
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, false, false, false, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, true);
+    } else {
+      return field->GetObj(obj);
+    }
+  }
+  return NULL;  // Will throw exception by checking with Thread::Current
+}
+
+extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
+                                      const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(NULL, new_value);
+    return 0;  // success
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    field->Set32(NULL, new_value);
+    return 0;  // success
+  }
+  return -1;  // failure
+}
+
+extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
+                                      uint64_t new_value, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(NULL, new_value);
+    return 0;  // success
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    field->Set64(NULL, new_value);
+    return 0;  // success
+  }
+  return -1;  // failure
+}
+
+extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
+                                       const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
+      field->SetObj(NULL, new_value);
+      return 0;  // success
+    }
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, true, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    field->SetObj(NULL, new_value);
+    return 0;  // success
+  }
+  return -1;  // failure
+}
+
+extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
+                                        const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
+  if (LIKELY(field != NULL && obj != NULL)) {
+    field->Set32(obj, new_value);
+    return 0;  // success
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int32_t));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+    } else {
+      field->Set32(obj, new_value);
+      return 0;  // success
+    }
+  }
+  return -1;  // failure
+}
+
+extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
+                                        Thread* self, Method** sp) {
+  Method* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
+  Method* referrer = sp[callee_save->GetFrameSizeInBytes() / sizeof(Method*)];
+  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
+  if (LIKELY(field != NULL  && obj != NULL)) {
+    field->Set64(obj, new_value);
+    return 0;  // success
+  }
+  *sp = callee_save;
+  self->SetTopOfStack(sp, 0);
+  field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int64_t));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+    } else {
+      field->Set64(obj, new_value);
+      return 0;  // success
+    }
+  }
+  return -1;  // failure
+}
+
+extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
+                                         const Method* referrer, Thread* self, Method** sp) {
+  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL && obj != NULL)) {
+    field->SetObj(obj, new_value);
+    return 0;  // success
+  }
+  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+  field = FindFieldFromCode(field_idx, referrer, self, false, false, true, sizeof(Object*));
+  if (LIKELY(field != NULL)) {
+    if (UNLIKELY(obj == NULL)) {
+      ThrowNullPointerExceptionForFieldAccess(self, field, false);
+    } else {
+      field->SetObj(obj, new_value);
+      return 0;  // success
+    }
+  }
+  return -1;  // failure
+}
+
 extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method,
                                           Thread* self, Method** sp) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
@@ -702,6 +963,30 @@ extern "C" int artHandleFillArrayDataFromCode(Array* array, const uint16_t* tabl
   return 0;  // Success
 }
 
+static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
+                                Thread* self, Method** sp, bool access_check, InvokeType type){
+  Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
+  if (UNLIKELY(method == NULL)) {
+    FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
+    if (UNLIKELY(this_object == NULL && type != kDirect && type != kStatic)) {
+      ThrowNullPointerExceptionForMethodAccess(self, caller_method, method_idx, type);
+      return 0;  // failure
+    }
+    method = FindMethodFromCode(method_idx, this_object, caller_method, self, access_check, type);
+    if (UNLIKELY(method == NULL)) {
+      CHECK(self->IsExceptionPending());
+      return 0;  // failure
+    }
+  }
+  DCHECK(!self->IsExceptionPending());
+  const void* code = method->GetCode();
+
+  uint32_t method_uint = reinterpret_cast<uint32_t>(method);
+  uint64_t code_uint = reinterpret_cast<uint32_t>(code);
+  uint64_t result = ((code_uint << 32) | method_uint);
+  return result;
+}
+
 // See comments in runtime_support_asm.S
 extern "C" uint64_t artInvokeInterfaceTrampoline(uint32_t method_idx, Object* this_object,
                                                  Method* caller_method, Thread* self,
diff --git a/src/runtime_support_common.cc b/src/runtime_support_common.cc
index 9309df9c99..71567a343e 100644
--- a/src/runtime_support_common.cc
+++ b/src/runtime_support_common.cc
@@ -229,244 +229,4 @@ Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread*
   return klass;
 }
 
-extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    return field->Get32(NULL);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    return field->Get32(NULL);
-  }
-  return 0;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    return field->Get64(NULL);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    return field->Get64(NULL);
-  }
-  return 0;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    return field->GetObj(NULL);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, false, false, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    return field->GetObj(NULL);
-  }
-  return NULL;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
-  if (LIKELY(field != NULL && obj != NULL)) {
-    return field->Get32(obj);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
-    } else {
-      return field->Get32(obj);
-    }
-  }
-  return 0;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
-  if (LIKELY(field != NULL && obj != NULL)) {
-    return field->Get64(obj);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
-    } else {
-      return field->Get64(obj);
-    }
-  }
-  return 0;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
-  if (LIKELY(field != NULL && obj != NULL)) {
-    return field->GetObj(obj);
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, false, false, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, true);
-    } else {
-      return field->GetObj(obj);
-    }
-  }
-  return NULL;  // Will throw exception by checking with Thread::Current
-}
-
-extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
-                                      const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    field->Set32(NULL, new_value);
-    return 0;  // success
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    field->Set32(NULL, new_value);
-    return 0;  // success
-  }
-  return -1;  // failure
-}
-
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                      uint64_t new_value, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    field->Set64(NULL, new_value);
-    return 0;  // success
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    field->Set64(NULL, new_value);
-    return 0;  // success
-  }
-  return -1;  // failure
-}
-
-extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
-                                       const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
-      field->SetObj(NULL, new_value);
-      return 0;  // success
-    }
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, true, false, true, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    field->SetObj(NULL, new_value);
-    return 0;  // success
-  }
-  return -1;  // failure
-}
-
-extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
-                                        const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
-  if (LIKELY(field != NULL && obj != NULL)) {
-    field->Set32(obj, new_value);
-    return 0;  // success
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int32_t));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
-    } else {
-      field->Set32(obj, new_value);
-      return 0;  // success
-    }
-  }
-  return -1;  // failure
-}
-
-extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
-#if !defined(ART_USE_LLVM_COMPILER)
-                                        Thread* self, Method** sp) {
-#else
-                                        const Method* referrer, Thread* self, Method** sp) {
-#endif
-#if !defined(ART_USE_LLVM_COMPILER)
-  Method* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
-  Method* referrer = sp[callee_save->GetFrameSizeInBytes() / sizeof(Method*)];
-#endif
-  Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
-  if (LIKELY(field != NULL  && obj != NULL)) {
-    field->Set64(obj, new_value);
-    return 0;  // success
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  *sp = callee_save;
-  self->SetTopOfStack(sp, 0);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int64_t));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
-    } else {
-      field->Set64(obj, new_value);
-      return 0;  // success
-    }
-  }
-  return -1;  // failure
-}
-
-extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
-                                         const Method* referrer, Thread* self, Method** sp) {
-  Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
-  if (LIKELY(field != NULL && obj != NULL)) {
-    field->SetObj(obj, new_value);
-    return 0;  // success
-  }
-#if !defined(ART_USE_LLVM_COMPILER)
-  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-#endif
-  field = FindFieldFromCode(field_idx, referrer, self, false, false, true, sizeof(Object*));
-  if (LIKELY(field != NULL)) {
-    if (UNLIKELY(obj == NULL)) {
-      ThrowNullPointerExceptionForFieldAccess(self, field, false);
-    } else {
-      field->SetObj(obj, new_value);
-      return 0;  // success
-    }
-  }
-  return -1;  // failure
-}
-
-
 }  // namespace art
diff --git a/src/runtime_support_common.h b/src/runtime_support_common.h
index adab93616e..8ef9d93657 100644
--- a/src/runtime_support_common.h
+++ b/src/runtime_support_common.h
@@ -144,14 +144,6 @@ static inline Object* AllocObjectFromCode(uint32_t type_idx, Method* method, Thr
   return klass->AllocObject();
 }
 
-// Place a special frame at the TOS that will save the callee saves for the given type
-static inline
-void  FinishCalleeSaveFrameSetup(Thread* self, Method** sp, Runtime::CalleeSaveType type) {
-  // Be aware the store below may well stomp on an incoming argument
-  *sp = Runtime::Current()->GetCalleeSaveMethod(type);
-  self->SetTopOfStack(sp, 0);
-}
-
 // Given the context of a calling Method, use its DexCache to resolve a type to an array Class. If
 // it cannot be resolved, throw an error. If it can, use it to create an array.
 // When verification/compiler hasn't been able to verify access, optionally perform an access
@@ -255,44 +247,6 @@ static inline Method* FindMethodFast(uint32_t method_idx, Object* this_object, c
 extern Method* FindMethodFromCode(uint32_t method_idx, Object* this_object, const Method* referrer,
                                   Thread* self, bool access_check, InvokeType type);
 
-static inline
-Method* _artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
-                         Thread* self, Method** sp, bool access_check, InvokeType type){
-  Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
-  if (UNLIKELY(method == NULL)) {
-#if !defined(ART_USE_LLVM_COMPILER)
-    FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
-    if (UNLIKELY(this_object == NULL && type != kDirect && type != kStatic)) {
-      ThrowNullPointerExceptionForMethodAccess(self, caller_method, method_idx, type);
-      return 0;  // failure
-    }
-#endif
-    method = FindMethodFromCode(method_idx, this_object, caller_method, self, access_check, type);
-    if (UNLIKELY(method == NULL)) {
-      CHECK(self->IsExceptionPending());
-      return 0;  // failure
-    }
-  }
-  DCHECK(!self->IsExceptionPending());
-  return method;
-}
-
-static inline
-uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
-                         Thread* self, Method** sp, bool access_check, InvokeType type){
-  Method* method = _artInvokeCommon(method_idx, this_object, caller_method,
-                                    self, sp, access_check, type);
-  if (method == NULL) {
-    return 0;  // failure
-  }
-  const void* code = method->GetCode();
-
-  uint32_t method_uint = reinterpret_cast<uint32_t>(method);
-  uint64_t code_uint = reinterpret_cast<uint32_t>(code);
-  uint64_t result = ((code_uint << 32) | method_uint);
-  return result;
-}
-
 extern Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread* self,
                                      bool can_run_clinit, bool verify_access);
 
@@ -301,46 +255,6 @@ static inline String* ResolveStringFromCode(const Method* referrer, uint32_t str
   return class_linker->ResolveString(string_idx, referrer);
 }
 
-extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp);
-
-extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp);
-
-extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp);
-
-extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp);
-
-extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp);
-
-extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp);
-
-extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
-                                      const Method* referrer, Thread* self, Method** sp);
-
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                      uint64_t new_value, Thread* self, Method** sp);
-
-extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
-                                       const Method* referrer, Thread* self, Method** sp);
-
-extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
-                                        const Method* referrer, Thread* self, Method** sp);
-
-extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
-#if !defined(ART_USE_LLVM_COMPILER)
-                                        Thread* self, Method** sp);
-#else
-                                        const Method* referrer, Thread* self, Method** sp);
-#endif
-
-extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
-                                         const Method* referrer, Thread* self, Method** sp);
-
 }  // namespace art
 
 #endif  // ART_SRC_RUNTIME_SUPPORT_COMMON_H_