diff --git a/src/dalvik_system_VMRuntime.cc b/src/dalvik_system_VMRuntime.cc
index 6f9480d..10732db 100644
--- a/src/dalvik_system_VMRuntime.cc
+++ b/src/dalvik_system_VMRuntime.cc
@@ -125,10 +125,10 @@
   // Note that targetSdkVersion may be CUR_DEVELOPMENT (10000).
   // Note that targetSdkVersion may be 0, meaning "current".
   if (targetSdkVersion > 0 && targetSdkVersion <= 13 /* honeycomb-mr2 */) {
+    JNIEnvExt* env_ext = reinterpret_cast<JNIEnvExt*>(env);
     // TODO: running with CheckJNI should override this and force you to obey the strictest rules.
     LOG(INFO) << "Turning on JNI app bug workarounds for target SDK version " << targetSdkVersion << "...";
-    // Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs = true;
-    UNIMPLEMENTED(WARNING) << "Support work arounds for app JNI bugs";
+    env_ext->vm->work_around_app_jni_bugs = true;
   }
 }
 
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 8b61226..d0a6776 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -2252,7 +2252,7 @@
 
       VLOG(jni) << "[Registering JNI native method " << PrettyMethod(m) << "]";
 
-      m->RegisterNative(methods[i].fnPtr);
+      m->RegisterNative(ts.Self(), methods[i].fnPtr);
     }
     return JNI_OK;
   }
diff --git a/src/object.cc b/src/object.cc
index 3aba5c8..cf15a64 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -34,6 +34,7 @@
 #include "monitor.h"
 #include "object_utils.h"
 #include "runtime.h"
+#include "runtime_support.h"
 #include "stack.h"
 #include "utils.h"
 
@@ -598,17 +599,34 @@
   return native_method != jni_stub;
 }
 
-void Method::RegisterNative(const void* native_method) {
+void Method::RegisterNative(Thread* self, const void* native_method) {
+  DCHECK(Thread::Current() == self);
   CHECK(IsNative()) << PrettyMethod(this);
   CHECK(native_method != NULL) << PrettyMethod(this);
-  SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_),
-                           native_method, false);
+  if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
+    SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_),
+                             native_method, false);
+  } else {
+    // We've been asked to associate this method with the given native method but are working
+    // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
+    // the native method to runtime support and store the target somewhere runtime support will
+    // find it.
+#if defined(__arm__)
+    SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_),
+        reinterpret_cast<const void*>(art_work_around_app_jni_bugs), false);
+#else
+    UNIMPLEMENTED(FATAL);
+#endif
+    SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(Method, gc_map_),
+        reinterpret_cast<const uint8_t*>(native_method), false);
+  }
 }
 
 void Method::UnregisterNative() {
   CHECK(IsNative()) << PrettyMethod(this);
   // restore stub to lookup native pointer via dlsym
-  RegisterNative(Runtime::Current()->GetJniDlsymLookupStub()->GetData());
+  SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_),
+      Runtime::Current()->GetJniDlsymLookupStub()->GetData(), false);
 }
 
 void Class::SetStatus(Status new_status) {
diff --git a/src/object.h b/src/object.h
index f9c8eb7..da8064f 100644
--- a/src/object.h
+++ b/src/object.h
@@ -762,7 +762,7 @@
 
   bool IsRegistered() const;
 
-  void RegisterNative(const void* native_method);
+  void RegisterNative(Thread* self, const void* native_method);
 
   void UnregisterNative();
 
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index f158680..d9d7e90 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -131,21 +131,21 @@
   return thread->DecodeJObject(obj);
 }
 
-extern void* FindNativeMethod(Thread* thread) {
-  DCHECK(Thread::Current() == thread);
+extern void* FindNativeMethod(Thread* self) {
+  DCHECK(Thread::Current() == self);
 
-  Method* method = const_cast<Method*>(thread->GetCurrentMethod());
+  Method* method = const_cast<Method*>(self->GetCurrentMethod());
   DCHECK(method != NULL);
 
   // Lookup symbol address for method, on failure we'll return NULL with an
   // exception set, otherwise we return the address of the method we found.
-  void* native_code = thread->GetJniEnv()->vm->FindCodeForNativeMethod(method);
+  void* native_code = self->GetJniEnv()->vm->FindCodeForNativeMethod(method);
   if (native_code == NULL) {
-    DCHECK(thread->IsExceptionPending());
+    DCHECK(self->IsExceptionPending());
     return NULL;
   } else {
     // Register so that future calls don't come here
-    method->RegisterNative(native_code);
+    method->RegisterNative(self, native_code);
     return native_code;
   }
 }
@@ -510,6 +510,74 @@
   return code;
 }
 
+static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
+  intptr_t value = *arg_ptr;
+  Object** value_as_jni_rep = reinterpret_cast<Object**>(value);
+  Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
+  CHECK(Heap::IsHeapAddress(value_as_work_around_rep));
+  *arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
+}
+
+extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp) {
+  DCHECK(Thread::Current() == self);
+  // TODO: this code is specific to ARM
+  // On entry the stack pointed by sp is:
+  // | arg3   | <- Calling JNI method's frame (and extra bit for out args)
+  // | LR     |
+  // | R3     |    arg2
+  // | R2     |    arg1
+  // | R1     |    jclass/jobject
+  // | R0     |    JNIEnv
+  // | unused |
+  // | unused |
+  // | unused | <- sp
+  Method* jni_method = self->GetTopOfStack().GetMethod();
+  DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
+  intptr_t* arg_ptr = sp + 4;  // pointer to r1 on stack
+  // Fix up this/jclass argument
+  WorkAroundJniBugsForJobject(arg_ptr);
+  arg_ptr++;
+  // Fix up jobject arguments
+  MethodHelper mh(jni_method);
+  int reg_num = 2;  // Current register being processed, -1 for stack arguments.
+  for (int32_t i = 1; i < mh.GetShortyLength(); i++) {
+    char shorty_char = mh.GetShorty()[i];
+    if (shorty_char == 'L') {
+      WorkAroundJniBugsForJobject(arg_ptr);
+    }
+    if (shorty_char == 'J' || shorty_char == 'D') {
+      if (reg_num == 2) {
+        arg_ptr = sp + 8;  // skip to out arguments
+        reg_num = -1;
+      } else if (reg_num == 3) {
+        arg_ptr = sp + 10;  // skip to out arguments plus 2 slots as long must be aligned
+        reg_num = -1;
+      } else {
+        DCHECK(reg_num == -1);
+        if ((reinterpret_cast<intptr_t>(arg_ptr) & 7) == 4) {
+          arg_ptr += 3;  // unaligned, pad and move through stack arguments
+        } else {
+          arg_ptr += 2;  // aligned, move through stack arguments
+        }
+      }
+    } else {
+      if (reg_num == 2) {
+        arg_ptr++; // move through register arguments
+        reg_num++;
+      } else if (reg_num == 3) {
+        arg_ptr = sp + 8;  // skip to outgoing stack arguments
+        reg_num = -1;
+      } else {
+        DCHECK(reg_num == -1);
+        arg_ptr++;  // move through stack arguments
+      }
+    }
+  }
+  // Load expected destination, see Method::RegisterNative
+  return reinterpret_cast<const void*>(jni_method->GetGcMapRaw());
+}
+
+
 // Fast path field resolution that can't throw exceptions
 static Field* FindFieldFast(uint32_t field_idx, const Method* referrer, bool is_primitive,
                             size_t expected_size) {
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 305bbf6..97197e6 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -99,6 +99,7 @@
   extern "C" void* art_resolve_string_from_code(void*, uint32_t);
   extern "C" void* art_resolve_method_from_code(void* referrer, uint32_t method_idx, bool is_direct);
   extern "C" void art_update_debugger(void*, void*, int32_t, void*);
+  extern "C" void art_work_around_app_jni_bugs();
 
   /* Conversions */
   extern "C" float __aeabi_i2f(int op1);             // OP_INT_TO_FLOAT
diff --git a/src/runtime_support_arm.S b/src/runtime_support_arm.S
index b337ebc..efa6ef8 100644
--- a/src/runtime_support_arm.S
+++ b/src/runtime_support_arm.S
@@ -210,6 +210,23 @@
 INVOKE_TRAMPOLINE art_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
 INVOKE_TRAMPOLINE art_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
 
+    .global art_work_around_app_jni_bugs
+    .extern artWorkAroundAppJniBugs
+    /*
+     * Entry point of native methods when JNI bug compatibility is enabled.
+     */
+art_work_around_app_jni_bugs:
+    @ save registers that may contain arguments and LR that will be crushed by a call
+    push {r0-r3, lr}
+    sub sp, #12      @ 3 words of space for alignment
+    mov r0, r9       @ pass Thread::Current
+    mov r1, sp       @ pass SP
+    bl  artWorkAroundAppJniBugs  @ (Thread*, SP)
+    add sp, #12      @ rewind stack
+    mov r12, r0      @ save target address
+    pop {r0-r3, lr}  @ restore possibly modified argument registers
+    bx  r12          @ tail call into JNI routine
+
     .global art_handle_fill_data_from_code
     .extern artHandleFillArrayDataFromCode
     /*