diff --git a/build/Android.common.mk b/build/Android.common.mk
index 34e8627..c5a6407 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -147,7 +147,6 @@
 	src/card_table.cc \
 	src/check_jni.cc \
 	src/class_linker.cc \
-	src/class_loader.cc \
 	src/compiled_method.cc \
 	src/compiler.cc \
 	src/debugger.cc \
@@ -175,6 +174,7 @@
 	src/jdwp/jdwp_main.cc \
 	src/jdwp/jdwp_socket.cc \
 	src/jni_internal.cc \
+	src/jobject_comparator.cc \
 	src/logging.cc \
 	src/mark_stack.cc \
 	src/mark_sweep.cc \
@@ -223,8 +223,6 @@
 	src/reflection.cc \
 	src/runtime.cc \
 	src/runtime_support.cc \
-	src/scoped_thread_list_lock.cc \
-	src/scoped_thread_list_lock_releaser.cc \
 	src/signal_catcher.cc \
 	src/space.cc \
 	src/space_bitmap.cc \
diff --git a/src/card_table.h b/src/card_table.h
index d065bed..e1d0646 100644
--- a/src/card_table.h
+++ b/src/card_table.h
@@ -74,7 +74,9 @@
 
   // For every dirty card between begin and end invoke the visitor with the specified argument.
   template <typename Visitor>
-  void Scan(SpaceBitmap* bitmap, byte* scan_begin, byte* scan_end, const Visitor& visitor) const {
+  void Scan(SpaceBitmap* bitmap, byte* scan_begin, byte* scan_end, const Visitor& visitor) const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(bitmap->HasAddress(scan_begin));
     DCHECK(bitmap->HasAddress(scan_end - 1));  // scan_end is the byte after the last byte we scan.
     byte* card_cur = CardFromAddr(scan_begin);
diff --git a/src/check_jni.cc b/src/check_jni.cc
index 47f20e1..b387f5f 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -22,7 +22,7 @@
 #include "class_linker.h"
 #include "logging.h"
 #include "object_utils.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "thread.h"
 #include "runtime.h"
@@ -35,6 +35,7 @@
 
 static void JniAbort(const char* jni_function_name, const char* msg) {
   Thread* self = Thread::Current();
+  ScopedObjectAccess soa(self);
   Method* current_method = self->GetCurrentMethod();
 
   std::ostringstream os;
@@ -54,7 +55,11 @@
   if (vm->check_jni_abort_hook != NULL) {
     vm->check_jni_abort_hook(vm->check_jni_abort_hook_data, os.str());
   } else {
-    self->SetState(kNative); // Ensure that we get a native stack trace for this thread.
+    {
+      MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+      CHECK_NE(self->GetState(), kRunnable);
+      self->SetState(kNative); // Ensure that we get a native stack trace for this thread.
+    }
     LOG(FATAL) << os.str();
   }
 }
@@ -120,7 +125,8 @@
   NULL
 };
 
-static bool ShouldTrace(JavaVMExt* vm, const Method* method) {
+static bool ShouldTrace(JavaVMExt* vm, const Method* method)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // If both "-Xcheck:jni" and "-Xjnitrace:" are enabled, we print trace messages
   // when a native method that matches the -Xjnitrace argument calls a JNI function
   // such as NewByteArray.
@@ -146,16 +152,27 @@
 class ScopedCheck {
  public:
   // For JNIEnv* functions.
-  explicit ScopedCheck(JNIEnv* env, int flags, const char* functionName) : ts_(env) {
+  explicit ScopedCheck(JNIEnv* env, int flags, const char* functionName)
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      : soa_(env) {
     Init(flags, functionName, true);
     CheckThread(flags);
   }
 
   // For JavaVM* functions.
-  explicit ScopedCheck(JavaVM* vm, bool has_method, const char* functionName) : ts_(vm) {
+  // TODO: it's not correct that this is a lock function, but making it so aids annotalysis.
+  explicit ScopedCheck(JavaVM* vm, bool has_method, const char* functionName)
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      : soa_(vm) {
     Init(kFlag_Invocation, functionName, has_method);
   }
 
+  ~ScopedCheck() UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {}
+
+  const ScopedObjectAccess& soa() {
+    return soa_;
+  }
+
   bool ForceCopy() {
     return Runtime::Current()->GetJavaVM()->force_copy;
   }
@@ -179,7 +196,8 @@
    *
    * Works for both static and instance fields.
    */
-  void CheckFieldType(jobject java_object, jfieldID fid, char prim, bool isStatic) {
+  void CheckFieldType(jobject java_object, jfieldID fid, char prim, bool isStatic)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Field* f = CheckFieldID(fid);
     if (f == NULL) {
       return;
@@ -187,7 +205,7 @@
     Class* field_type = FieldHelper(f).GetType();
     if (!field_type->IsPrimitive()) {
       if (java_object != NULL) {
-        Object* obj = ts_.Decode<Object*>(java_object);
+        Object* obj = soa_.Decode<Object*>(java_object);
         // If java_object is a weak global ref whose referent has been cleared,
         // obj will be NULL.  Otherwise, obj should always be non-NULL
         // and valid.
@@ -224,8 +242,9 @@
    *
    * Assumes "jobj" has already been validated.
    */
-  void CheckInstanceFieldID(jobject java_object, jfieldID fid) {
-    Object* o = ts_.Decode<Object*>(java_object);
+  void CheckInstanceFieldID(jobject java_object, jfieldID fid)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    Object* o = soa_.Decode<Object*>(java_object);
     if (o == NULL || !Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
       JniAbortF(function_name_, "field operation on invalid %s: %p",
                 ToStr<IndirectRefKind>(GetIndirectRefKind(java_object)).c_str(), java_object);
@@ -257,7 +276,8 @@
    * Verify that the method's return type matches the type of call.
    * 'expectedType' will be "L" for all objects, including arrays.
    */
-  void CheckSig(jmethodID mid, const char* expectedType, bool isStatic) {
+  void CheckSig(jmethodID mid, const char* expectedType, bool isStatic)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
@@ -282,8 +302,9 @@
    *
    * Assumes "java_class" has already been validated.
    */
-  void CheckStaticFieldID(jclass java_class, jfieldID fid) {
-    Class* c = ts_.Decode<Class*>(java_class);
+  void CheckStaticFieldID(jclass java_class, jfieldID fid)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    Class* c = soa_.Decode<Class*>(java_class);
     const Field* f = CheckFieldID(fid);
     if (f == NULL) {
       return;
@@ -303,12 +324,13 @@
    *
    * Instances of "java_class" must be instances of the method's declaring class.
    */
-  void CheckStaticMethod(jclass java_class, jmethodID mid) {
+  void CheckStaticMethod(jclass java_class, jmethodID mid)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const Method* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
-    Class* c = ts_.Decode<Class*>(java_class);
+    Class* c = soa_.Decode<Class*>(java_class);
     if (!c->IsAssignableFrom(m->GetDeclaringClass())) {
       JniAbortF(function_name_, "can't call static %s on class %s",
                 PrettyMethod(m).c_str(), PrettyClass(c).c_str());
@@ -322,12 +344,13 @@
    * (Note the mid might point to a declaration in an interface; this
    * will be handled automatically by the instanceof check.)
    */
-  void CheckVirtualMethod(jobject java_object, jmethodID mid) {
+  void CheckVirtualMethod(jobject java_object, jmethodID mid)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const Method* m = CheckMethodID(mid);
     if (m == NULL) {
       return;
     }
-    Object* o = ts_.Decode<Object*>(java_object);
+    Object* o = soa_.Decode<Object*>(java_object);
     if (!o->InstanceOf(m->GetDeclaringClass())) {
       JniAbortF(function_name_, "can't call %s on instance of %s",
                 PrettyMethod(m).c_str(), PrettyTypeOf(o).c_str());
@@ -370,11 +393,12 @@
    *
    * Use the kFlag_NullableUtf flag where 'u' field(s) are nullable.
    */
-  void Check(bool entry, const char* fmt0, ...) {
+  void Check(bool entry, const char* fmt0, ...)
+      SHARED_LOCKS_REQUIRED (GlobalSynchronization::mutator_lock_) {
     va_list ap;
 
     const Method* traceMethod = NULL;
-    if ((!ts_.Vm()->trace.empty() || VLOG_IS_ON(third_party_jni)) && has_method_) {
+    if ((!soa_.Vm()->trace.empty() || VLOG_IS_ON(third_party_jni)) && has_method_) {
       // We need to guard some of the invocation interface's calls: a bad caller might
       // use DetachCurrentThread or GetEnv on a thread that's not yet attached.
       Thread* self = Thread::Current();
@@ -383,7 +407,7 @@
       }
     }
 
-    if (((flags_ & kFlag_ForceTrace) != 0) || (traceMethod != NULL && ShouldTrace(ts_.Vm(), traceMethod))) {
+    if (((flags_ & kFlag_ForceTrace) != 0) || (traceMethod != NULL && ShouldTrace(soa_.Vm(), traceMethod))) {
       va_start(ap, fmt0);
       std::string msg;
       for (const char* fmt = fmt0; *fmt;) {
@@ -571,7 +595,8 @@
    * Because we're looking at an object on the GC heap, we have to switch
    * to "running" mode before doing the checks.
    */
-  bool CheckInstance(InstanceKind kind, jobject java_object) {
+  bool CheckInstance(InstanceKind kind, jobject java_object)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const char* what = NULL;
     switch (kind) {
     case kClass:
@@ -598,7 +623,7 @@
       return false;
     }
 
-    Object* obj = ts_.Decode<Object*>(java_object);
+    Object* obj = soa_.Decode<Object*>(java_object);
     if (!Runtime::Current()->GetHeap()->IsHeapAddress(obj)) {
       JniAbortF(function_name_, "%s is an invalid %s: %p (%p)",
                 what, ToStr<IndirectRefKind>(GetIndirectRefKind(java_object)).c_str(), java_object, obj);
@@ -645,13 +670,13 @@
    *
    * Since we're dealing with objects, switch to "running" mode.
    */
-  void CheckArray(jarray java_array) {
+  void CheckArray(jarray java_array) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (java_array == NULL) {
       JniAbortF(function_name_, "jarray was NULL");
       return;
     }
 
-    Array* a = ts_.Decode<Array*>(java_array);
+    Array* a = soa_.Decode<Array*>(java_array);
     if (!Runtime::Current()->GetHeap()->IsHeapAddress(a)) {
       JniAbortF(function_name_, "jarray is an invalid %s: %p (%p)",
                 ToStr<IndirectRefKind>(GetIndirectRefKind(java_array)).c_str(), java_array, a);
@@ -666,12 +691,12 @@
     }
   }
 
-  Field* CheckFieldID(jfieldID fid) {
+  Field* CheckFieldID(jfieldID fid) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (fid == NULL) {
       JniAbortF(function_name_, "jfieldID was NULL");
       return NULL;
     }
-    Field* f = ts_.DecodeField(fid);
+    Field* f = soa_.DecodeField(fid);
     if (!Runtime::Current()->GetHeap()->IsHeapAddress(f) || !f->IsField()) {
       JniAbortF(function_name_, "invalid jfieldID: %p", fid);
       return NULL;
@@ -679,12 +704,12 @@
     return f;
   }
 
-  Method* CheckMethodID(jmethodID mid) {
+  Method* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (mid == NULL) {
       JniAbortF(function_name_, "jmethodID was NULL");
       return NULL;
     }
-    Method* m = ts_.DecodeMethod(mid);
+    Method* m = soa_.DecodeMethod(mid);
     if (!Runtime::Current()->GetHeap()->IsHeapAddress(m) || !m->IsMethod()) {
       JniAbortF(function_name_, "invalid jmethodID: %p", mid);
       return NULL;
@@ -698,12 +723,13 @@
    *
    * Switches to "running" mode before performing checks.
    */
-  void CheckObject(jobject java_object) {
+  void CheckObject(jobject java_object)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (java_object == NULL) {
       return;
     }
 
-    Object* o = ts_.Decode<Object*>(java_object);
+    Object* o = soa_.Decode<Object*>(java_object);
     if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
       // TODO: when we remove work_around_app_jni_bugs, this should be impossible.
       JniAbortF(function_name_, "native code passing in reference to invalid %s: %p",
@@ -721,7 +747,7 @@
     }
   }
 
-  void CheckThread(int flags) {
+  void CheckThread(int flags) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Thread* self = Thread::Current();
     if (self == NULL) {
       JniAbortF(function_name_, "a thread (tid %d) is making JNI calls without being attached", GetTid());
@@ -733,13 +759,13 @@
 
     // Verify that the current thread is (a) attached and (b) associated with
     // this particular instance of JNIEnv.
-    if (ts_.Env() != threadEnv) {
-      if (ts_.Vm()->work_around_app_jni_bugs) {
+    if (soa_.Env() != threadEnv) {
+      if (soa_.Vm()->work_around_app_jni_bugs) {
         // If we're keeping broken code limping along, we need to suppress the abort...
-        LOG(ERROR) << "APP BUG DETECTED: thread " << *self << " using JNIEnv* from thread " << *ts_.Self();
+        LOG(ERROR) << "APP BUG DETECTED: thread " << *self << " using JNIEnv* from thread " << *soa_.Self();
       } else {
         JniAbortF(function_name_, "thread %s using JNIEnv* from thread %s",
-                  ToStr<Thread>(*self).c_str(), ToStr<Thread>(*ts_.Self()).c_str());
+                  ToStr<Thread>(*self).c_str(), ToStr<Thread>(*soa_.Self()).c_str());
         return;
       }
     }
@@ -778,7 +804,7 @@
       // TODO: do we care any more? art always dumps pending exceptions on aborting threads.
       if (type != "java.lang.OutOfMemoryError") {
         JniAbortF(function_name_, "JNI %s called with pending exception: %s",
-                  function_name_, type.c_str(), jniGetStackTrace(ts_.Env()).c_str());
+                  function_name_, type.c_str(), jniGetStackTrace(soa_.Env()).c_str());
       } else {
         JniAbortF(function_name_, "JNI %s called with %s pending", function_name_, type.c_str());
       }
@@ -855,7 +881,7 @@
     return 0;
   }
 
-  const ScopedJniThreadState ts_;
+  const ScopedObjectAccess soa_;
   const char* function_name_;
   int flags_;
   bool has_method_;
@@ -1051,9 +1077,9 @@
  * data are allowed.  Returns a pointer to the copied data.
  */
 static void* CreateGuardedPACopy(JNIEnv* env, const jarray java_array, jboolean* isCopy) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
 
-  Array* a = ts.Decode<Array*>(java_array);
+  Array* a = soa.Decode<Array*>(java_array);
   size_t component_size = a->GetClass()->GetComponentSize();
   size_t byte_count = a->GetLength() * component_size;
   void* result = GuardedCopy::Create(a->GetRawData(component_size), byte_count, true);
@@ -1072,8 +1098,8 @@
     return;
   }
 
-  ScopedJniThreadState ts(env);
-  Array* a = ts.Decode<Array*>(java_array);
+  ScopedObjectAccess soa(env);
+  Array* a = soa.Decode<Array*>(java_array);
 
   GuardedCopy::Check(__FUNCTION__, dataBuf, true);
 
@@ -1461,8 +1487,7 @@
     CHECK_JNI_ENTRY(kFlag_CritOkay, "Esp", env, java_string, isCopy);
     const jchar* result = baseEnv(env)->GetStringChars(env, java_string, isCopy);
     if (sc.ForceCopy() && result != NULL) {
-      ScopedJniThreadState ts(env);
-      String* s = ts.Decode<String*>(java_string);
+      String* s = sc.soa().Decode<String*>(java_string);
       int byteCount = s->GetLength() * 2;
       result = (const jchar*) GuardedCopy::Create(result, byteCount, false);
       if (isCopy != NULL) {
@@ -1689,8 +1714,7 @@
     CHECK_JNI_ENTRY(kFlag_CritGet, "Esp", env, java_string, isCopy);
     const jchar* result = baseEnv(env)->GetStringCritical(env, java_string, isCopy);
     if (sc.ForceCopy() && result != NULL) {
-      ScopedJniThreadState ts(env);
-      String* s = ts.Decode<String*>(java_string);
+      String* s = sc.soa().Decode<String*>(java_string);
       int byteCount = s->GetLength() * 2;
       result = (const jchar*) GuardedCopy::Create(result, byteCount, false);
       if (isCopy != NULL) {
diff --git a/src/class_linker.cc b/src/class_linker.cc
index df14a41..3514612 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -45,8 +45,8 @@
 #if defined(ART_USE_LLVM_COMPILER)
 #include "compiler_llvm/runtime_support_llvm.h"
 #endif
-#include "scoped_jni_thread_state.h"
 #include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "space_bitmap.h"
 #include "stack_indirect_reference_table.h"
@@ -58,7 +58,9 @@
 
 namespace art {
 
-static void ThrowNoClassDefFoundError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowNoClassDefFoundError(const char* fmt, ...)
+    __attribute__((__format__(__printf__, 1, 2)))
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 static void ThrowNoClassDefFoundError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
@@ -66,7 +68,9 @@
   va_end(args);
 }
 
-static void ThrowClassFormatError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowClassFormatError(const char* fmt, ...)
+    __attribute__((__format__(__printf__, 1, 2)))
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 static void ThrowClassFormatError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
@@ -74,7 +78,9 @@
   va_end(args);
 }
 
-static void ThrowLinkageError(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowLinkageError(const char* fmt, ...)
+    __attribute__((__format__(__printf__, 1, 2)))
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 static void ThrowLinkageError(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
@@ -83,7 +89,8 @@
 }
 
 static void ThrowNoSuchMethodError(bool is_direct, Class* c, const StringPiece& name,
-                                   const StringPiece& signature) {
+                                   const StringPiece& signature)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ClassHelper kh(c);
   std::ostringstream msg;
   msg << "no " << (is_direct ? "direct" : "virtual") << " method " << name << signature
@@ -96,7 +103,8 @@
 }
 
 static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
-                                  const StringPiece& name) {
+                                  const StringPiece& name)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ClassHelper kh(c);
   std::ostringstream msg;
   msg << "no " << scope << "field " << name << " of type " << type
@@ -108,7 +116,9 @@
   Thread::Current()->ThrowNewException("Ljava/lang/NoSuchFieldError;", msg.str().c_str());
 }
 
-static void ThrowNullPointerException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)));
+static void ThrowNullPointerException(const char* fmt, ...)
+    __attribute__((__format__(__printf__, 1, 2)))
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 static void ThrowNullPointerException(const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
@@ -116,7 +126,8 @@
   va_end(args);
 }
 
-static void ThrowEarlierClassFailure(Class* c) {
+static void ThrowEarlierClassFailure(Class* c)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // The class failed to initialize on a previous attempt, so we want to throw
   // a NoClassDefFoundError (v2 2.17.5).  The exception to this rule is if we
   // failed in verification, in which case v2 5.4.1 says we need to re-throw
@@ -134,7 +145,8 @@
   }
 }
 
-static void WrapExceptionInInitializer() {
+static void WrapExceptionInInitializer()
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Thread* self = Thread::Current();
   JNIEnv* env = self->GetJniEnv();
 
@@ -172,8 +184,6 @@
   "Ljava/lang/reflect/Method;",
   "Ljava/lang/reflect/Proxy;",
   "Ljava/lang/ClassLoader;",
-  "Ldalvik/system/BaseDexClassLoader;",
-  "Ldalvik/system/PathClassLoader;",
   "Ljava/lang/Throwable;",
   "Ljava/lang/ClassNotFoundException;",
   "Ljava/lang/StackTraceElement;",
@@ -212,8 +222,8 @@
 }
 
 ClassLinker::ClassLinker(InternTable* intern_table)
-    : dex_lock_("ClassLinker dex lock"),
-      classes_lock_("ClassLinker classes lock"),
+    // dex_lock_ is recursive as it may be used in stack dumping.
+    : dex_lock_("ClassLinker dex lock", kDefaultMutexLevel, true),
       class_roots_(NULL),
       array_iftable_(NULL),
       init_done_(false),
@@ -433,20 +443,11 @@
       java_lang_ref_WeakReference->GetAccessFlags() |
           kAccClassIsReference | kAccClassIsWeakReference);
 
-  // Setup the ClassLoaders, verifying the object_size_
+  // Setup the ClassLoader, verifying the object_size_
   Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
   CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
   SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
 
-  Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
-  CHECK_EQ(dalvik_system_BaseDexClassLoader->GetObjectSize(), sizeof(BaseDexClassLoader));
-  SetClassRoot(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
-
-  Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
-  CHECK_EQ(dalvik_system_PathClassLoader->GetObjectSize(), sizeof(PathClassLoader));
-  SetClassRoot(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
-  PathClassLoader::SetClass(dalvik_system_PathClassLoader);
-
   // Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
   // java.lang.StackTraceElement as a convenience
   SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
@@ -536,7 +537,7 @@
     Class* c = GetClassRoot(ClassRoot(i));
     if (!c->IsArrayClass() && !c->IsPrimitive()) {
       EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
-      CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+      self->AssertNoPendingException();
     }
   }
 }
@@ -656,11 +657,11 @@
 }
 
 const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
+  MutexLock mu(dex_lock_);
   return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
 }
 
 const OatFile* ClassLinker::FindOpenedOatFileFromDexLocation(const std::string& dex_location) {
-  MutexLock mu(dex_lock_);
   for (size_t i = 0; i < oat_files_.size(); i++) {
     const OatFile* oat_file = oat_files_[i];
     DCHECK(oat_file != NULL);
@@ -698,6 +699,12 @@
 
 const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
                                                               const std::string& oat_location) {
+  MutexLock mu(dex_lock_);
+  return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
+}
+
+const DexFile* ClassLinker::FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
+                                                                    const std::string& oat_location) {
   uint32_t dex_location_checksum;
   if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
     LOG(ERROR) << "Failed to compute checksum '" << dex_location << "'";
@@ -713,13 +720,12 @@
   }
 
   // Generate the output oat file for the dex file
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   UniquePtr<File> file(OS::OpenFile(oat_location.c_str(), true));
   if (file.get() == NULL) {
     LOG(ERROR) << "Failed to create oat file: " << oat_location;
     return NULL;
   }
-  if (!class_linker->GenerateOatFile(dex_location, file->Fd(), oat_location)) {
+  if (!GenerateOatFile(dex_location, file->Fd(), oat_location)) {
     LOG(ERROR) << "Failed to generate oat file: " << oat_location;
     return NULL;
   }
@@ -734,7 +740,7 @@
     LOG(ERROR) << "Failed to open generated oat file: " << oat_location;
     return NULL;
   }
-  class_linker->RegisterOatFile(*oat_file);
+  RegisterOatFileLocked(*oat_file);
   const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_location);
   if (oat_dex_file == NULL) {
     LOG(ERROR) << "Failed to find dex file in generated oat file: " << oat_location;
@@ -808,7 +814,7 @@
   // Look for an existing file next to dex. for example, for
   // /foo/bar/baz.jar, look for /foo/bar/baz.jar.oat.
   std::string oat_filename(OatFile::DexFilenameToOatFilename(dex_location));
-  const OatFile* oat_file = FindOatFileFromOatLocation(oat_filename);
+  const OatFile* oat_file = FindOatFileFromOatLocationLocked(oat_filename);
   if (oat_file != NULL) {
     uint32_t dex_location_checksum;
     if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
@@ -829,7 +835,7 @@
   // Look for an existing file in the art-cache, validating the result if found
   // not found in /foo/bar/baz.oat? try /data/art-cache/foo@bar@baz.oat
   std::string cache_location(GetArtCacheFilenameOrDie(oat_filename));
-  oat_file = FindOatFileFromOatLocation(cache_location);
+  oat_file = FindOatFileFromOatLocationLocked(cache_location);
   if (oat_file != NULL) {
     uint32_t dex_location_checksum;
     if (!DexFile::GetChecksum(dex_location, dex_location_checksum)) {
@@ -850,11 +856,10 @@
 
   // Try to generate oat file if it wasn't found or was obsolete.
   std::string oat_cache_filename(GetArtCacheFilenameOrDie(oat_filename));
-  return FindOrCreateOatFileForDexLocation(dex_location, oat_cache_filename);
+  return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_cache_filename);
 }
 
 const OatFile* ClassLinker::FindOpenedOatFileFromOatLocation(const std::string& oat_location) {
-  MutexLock mu(dex_lock_);
   for (size_t i = 0; i < oat_files_.size(); i++) {
     const OatFile* oat_file = oat_files_[i];
     DCHECK(oat_file != NULL);
@@ -867,6 +872,10 @@
 
 const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
   MutexLock mu(dex_lock_);
+  return FindOatFileFromOatLocationLocked(oat_location);
+}
+
+const OatFile* ClassLinker::FindOatFileFromOatLocationLocked(const std::string& oat_location) {
   const OatFile* oat_file = FindOpenedOatFileFromOatLocation(oat_location);
   if (oat_file != NULL) {
     return oat_file;
@@ -942,7 +951,6 @@
   IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
   LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
   ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
-  PathClassLoader::SetClass(GetClassRoot(kDalvikSystemPathClassLoader));
   Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
   StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
 
@@ -984,7 +992,7 @@
   }
 
   {
-    MutexLock mu(classes_lock_);
+    MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
     typedef Table::const_iterator It;  // TODO: C++0x auto
     for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
       visitor(it->second, arg);
@@ -998,7 +1006,7 @@
 }
 
 void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   typedef Table::const_iterator It;  // TODO: C++0x auto
   for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
     if (!visitor(it->second, arg)) {
@@ -1012,6 +1020,24 @@
   }
 }
 
+static bool GetClassesVisitor(Class* c, void* arg) {
+  std::set<Class*>* classes = reinterpret_cast<std::set<Class*>*>(arg);
+  classes->insert(c);
+  return true;
+}
+
+void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
+  std::set<Class*> classes;
+  VisitClasses(GetClassesVisitor, &classes);
+  typedef std::set<Class*>::const_iterator It;  // TODO: C++0x auto
+  for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
+    if (!visitor(*it, arg)) {
+      return;
+    }
+  }
+}
+
+
 ClassLinker::~ClassLinker() {
   String::ResetClass();
   Field::ResetClass();
@@ -1024,7 +1050,6 @@
   IntArray::ResetArrayClass();
   LongArray::ResetArrayClass();
   ShortArray::ResetArrayClass();
-  PathClassLoader::ResetClass();
   Throwable::ResetClass();
   StackTraceElement::ResetClass();
   STLDeleteElements(&boot_class_path_);
@@ -1105,7 +1130,8 @@
       length);
 }
 
-static Class* EnsureResolved(Class* klass) {
+static Class* EnsureResolved(Class* klass)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   DCHECK(klass != NULL);
   // Wait for the class if it has not already been linked.
   Thread* self = Thread::Current();
@@ -1130,7 +1156,8 @@
   // Return the loaded class.  No exceptions should be pending.
   CHECK(klass->IsResolved()) << PrettyClass(klass);
   CHECK(!self->IsExceptionPending())
-      << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException());
+      << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException()) << "\n"
+      << self->GetException()->Dump();
   return klass;
 }
 
@@ -1142,7 +1169,7 @@
   DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
   Thread* self = Thread::Current();
   DCHECK(self != NULL);
-  CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+  self->AssertNoPendingException();
   if (descriptor[1] == '\0') {
     // only the descriptors of primitive types should be 1 character long, also avoid class lookup
     // for primitive classes that aren't backed by dex files.
@@ -1173,32 +1200,37 @@
     self->ClearException();
 
     // next try the compile time class path
-    const std::vector<const DexFile*>& class_path
-        = Runtime::Current()->GetCompileTimeClassPath(class_loader);
-    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
+    const std::vector<const DexFile*>* class_path;
+    {
+      ScopedObjectAccessUnchecked soa(Thread::Current());
+      ScopedLocalRef<jobject> jclass_loader(soa.Env(), soa.AddLocalReference<jobject>(class_loader));
+      class_path = &Runtime::Current()->GetCompileTimeClassPath(jclass_loader.get());
+    }
+
+    DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, *class_path);
     if (pair.second != NULL) {
       return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
     }
 
   } else {
-    ScopedJniThreadState ts(self->GetJniEnv());
-    ScopedLocalRef<jobject> class_loader_object(ts.Env(),
-                                                ts.AddLocalReference<jobject>(class_loader));
+    ScopedObjectAccessUnchecked soa(self->GetJniEnv());
+    ScopedLocalRef<jobject> class_loader_object(soa.Env(),
+                                                soa.AddLocalReference<jobject>(class_loader));
     std::string class_name_string(DescriptorToDot(descriptor));
-    ScopedLocalRef<jobject> result(ts.Env(), NULL);
+    ScopedLocalRef<jobject> result(soa.Env(), NULL);
     {
       ScopedThreadStateChange tsc(self, kNative);
-      ScopedLocalRef<jobject> class_name_object(ts.Env(),
-                                                ts.Env()->NewStringUTF(class_name_string.c_str()));
+      ScopedLocalRef<jobject> class_name_object(soa.Env(),
+                                                soa.Env()->NewStringUTF(class_name_string.c_str()));
       if (class_name_object.get() == NULL) {
         return NULL;
       }
       CHECK(class_loader_object.get() != NULL);
-      result.reset(ts.Env()->CallObjectMethod(class_loader_object.get(),
-                                              WellKnownClasses::java_lang_ClassLoader_loadClass,
-                                              class_name_object.get()));
+      result.reset(soa.Env()->CallObjectMethod(class_loader_object.get(),
+                                               WellKnownClasses::java_lang_ClassLoader_loadClass,
+                                               class_name_object.get()));
     }
-    if (ts.Env()->ExceptionCheck()) {
+    if (soa.Env()->ExceptionCheck()) {
       // If the ClassLoader threw, pass that exception up.
       return NULL;
     } else if (result.get() == NULL) {
@@ -1208,7 +1240,7 @@
       return NULL;
     } else {
       // success, return Class*
-      return ts.Decode<Class*>(result.get());
+      return soa.Decode<Class*>(result.get());
     }
   }
 
@@ -1428,7 +1460,9 @@
   }
 }
 
-static void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class, uint32_t method_index) {
+static void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class,
+                     uint32_t method_index)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Every kind of method should at least get an invoke stub from the oat_method.
   // non-abstract methods also get their code pointers.
   const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
@@ -1863,7 +1897,7 @@
     LOG(INFO) << "Loaded class " << descriptor << source;
   }
   size_t hash = StringPieceHash()(descriptor);
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   Table& classes = image_class ? image_classes_ : classes_;
   Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
 #ifndef NDEBUG
@@ -1880,7 +1914,7 @@
 
 bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   typedef Table::iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
   ClassHelper kh;
@@ -1905,7 +1939,7 @@
 
 Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   // TODO: determine if its better to search classes_ or image_classes_ first
   Class* klass = LookupClassLocked(descriptor, class_loader, hash, classes_);
   if (klass != NULL) {
@@ -1940,7 +1974,7 @@
 void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
   classes.clear();
   size_t hash = Hash(descriptor);
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   typedef Table::const_iterator It;  // TODO: C++0x auto
   // TODO: determine if its better to search classes_ or image_classes_ first
   ClassHelper kh(NULL, this);
@@ -1961,7 +1995,8 @@
 }
 
 #if !defined(NDEBUG) && !defined(ART_USE_LLVM_COMPILER)
-static void CheckMethodsHaveGcMaps(Class* klass) {
+static void CheckMethodsHaveGcMaps(Class* klass)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (!Runtime::Current()->IsStarted()) {
     return;
   }
@@ -2050,7 +2085,7 @@
           << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
           << " because: " << error_msg;
     }
-    DCHECK(!Thread::Current()->IsExceptionPending());
+    Thread::Current()->AssertNoPendingException();
     CHECK(verifier_failure == verifier::MethodVerifier::kNoFailure ||
           Runtime::Current()->IsCompiler());
     // Make sure all classes referenced by catch blocks are resolved
@@ -2064,7 +2099,7 @@
         << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8()
         << " because: " << error_msg;
     Thread* self = Thread::Current();
-    CHECK(!self->IsExceptionPending());
+    self->AssertNoPendingException();
     self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
     CHECK_EQ(klass->GetStatus(), Class::kStatusVerifying) << PrettyDescriptor(klass);
     klass->SetStatus(Class::kStatusError);
@@ -2300,7 +2335,8 @@
   return constructor;
 }
 
-static void CheckProxyConstructor(Method* constructor) {
+static void CheckProxyConstructor(Method* constructor)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   CHECK(constructor->IsConstructor());
   MethodHelper mh(constructor);
   CHECK_STREQ(mh.GetName(), "<init>");
@@ -2338,7 +2374,8 @@
   return method;
 }
 
-static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype) {
+static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Basic sanity
   CHECK(!prototype->IsFinal());
   CHECK(method->IsFinal());
@@ -2485,9 +2522,10 @@
   return success;
 }
 
-bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock) {
+bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   while (true) {
-    CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+    self->AssertNoPendingException();
     lock.Wait();
 
     // When we wake up, repeat the test for init-in-progress.  If
@@ -3096,8 +3134,11 @@
 }
 
 struct LinkFieldsComparator {
-  explicit LinkFieldsComparator(FieldHelper* fh) : fh_(fh) {}
-  bool operator()(const Field* field1, const Field* field2) {
+  explicit LinkFieldsComparator(FieldHelper* fh)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      : fh_(fh) {}
+  // No thread safety analysis as will be called from STL. Checked lock held in constructor.
+  bool operator()(const Field* field1, const Field* field2) NO_THREAD_SAFETY_ANALYSIS {
     // First come reference fields, then 64-bit, and finally 32-bit
     fh_->ChangeField(field1);
     Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
@@ -3497,7 +3538,7 @@
   // lock held, because it might need to resolve a field's type, which would try to take the lock.
   std::vector<Class*> all_classes;
   {
-    MutexLock mu(classes_lock_);
+    MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
     typedef Table::const_iterator It;  // TODO: C++0x auto
     for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
       all_classes.push_back(it->second);
@@ -3513,22 +3554,22 @@
 }
 
 void ClassLinker::DumpForSigQuit(std::ostream& os) const {
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   os << "Loaded classes: " << image_classes_.size() << " image classes; "
      << classes_.size() << " allocated classes\n";
 }
 
 size_t ClassLinker::NumLoadedClasses() const {
-  MutexLock mu(classes_lock_);
+  MutexLock mu(*GlobalSynchronization::classlinker_classes_lock_);
   return classes_.size() + image_classes_.size();
 }
 
 pid_t ClassLinker::GetClassesLockOwner() {
-  return classes_lock_.GetOwner();
+  return GlobalSynchronization::classlinker_classes_lock_->GetExclusiveOwnerTid();
 }
 
 pid_t ClassLinker::GetDexLockOwner() {
-  return dex_lock_.GetOwner();
+  return dex_lock_.GetExclusiveOwnerTid();
 }
 
 void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
diff --git a/src/class_linker.h b/src/class_linker.h
index 8ad8d2d..c69c442 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -45,46 +45,61 @@
  public:
   // Creates the class linker by boot strapping from dex files.
   static ClassLinker* CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
-                                         InternTable* intern_table);
+                                         InternTable* intern_table)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Creates the class linker from an image.
-  static ClassLinker* CreateFromImage(InternTable* intern_table);
+  static ClassLinker* CreateFromImage(InternTable* intern_table)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   ~ClassLinker();
 
   // Finds a class by its descriptor, loading it if necessary.
   // If class_loader is null, searches boot_class_path_.
-  Class* FindClass(const char* descriptor, ClassLoader* class_loader);
+  Class* FindClass(const char* descriptor, ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Class* FindSystemClass(const char* descriptor);
+  Class* FindSystemClass(const char* descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Define a new a class based on a ClassDef from a DexFile
   Class* DefineClass(const StringPiece& descriptor, ClassLoader* class_loader,
-                     const DexFile& dex_file, const DexFile::ClassDef& dex_class_def);
+                     const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
   // by the given 'class_loader'.
-  Class* LookupClass(const char* descriptor, const ClassLoader* class_loader);
+  Class* LookupClass(const char* descriptor, const ClassLoader* class_loader)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds all the classes with the given descriptor, regardless of ClassLoader.
-  void LookupClasses(const char* descriptor, std::vector<Class*>& classes);
+  void LookupClasses(const char* descriptor, std::vector<Class*>& classes)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Class* FindPrimitiveClass(char type);
+  Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // General class unloading is not supported, this is used to prune
   // unwanted classes during image writing.
-  bool RemoveClass(const char* descriptor, const ClassLoader* class_loader);
+  bool RemoveClass(const char* descriptor, const ClassLoader* class_loader)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void DumpAllClasses(int flags) const;
+  void DumpAllClasses(int flags) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void DumpForSigQuit(std::ostream& os) const;
+  void DumpForSigQuit(std::ostream& os) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
-  size_t NumLoadedClasses() const;
+  size_t NumLoadedClasses() const LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  String* ResolveString(uint32_t string_idx, const Method* referrer) {
+  String* ResolveString(uint32_t string_idx, const Method* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx);
     if (UNLIKELY(resolved_string == NULL)) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -97,14 +112,14 @@
 
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache.
-  String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache);
+  String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identity the
   // target DexCache and ClassLoader to use for resolution.
-  Class* ResolveType(const DexFile& dex_file,
-                     uint16_t type_idx,
-                     const Class* referrer) {
+  Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, const Class* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ResolveType(dex_file,
                        type_idx,
                        referrer->GetDexCache(),
@@ -114,7 +129,8 @@
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  Class* ResolveType(uint16_t type_idx, const Method* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Method* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
     if (UNLIKELY(resolved_type == NULL)) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -126,7 +142,8 @@
     return resolved_type;
   }
 
-  Class* ResolveType(uint16_t type_idx, const Field* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Field* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* declaring_class = referrer->GetDeclaringClass();
     DexCache* dex_cache = declaring_class->GetDexCache();
     Class* resolved_type = dex_cache->GetResolvedType(type_idx);
@@ -145,7 +162,8 @@
   Class* ResolveType(const DexFile& dex_file,
                      uint16_t type_idx,
                      DexCache* dex_cache,
-                     ClassLoader* class_loader);
+                     ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a method with a given ID from the DexFile, storing the
   // result in DexCache. The ClassLinker and ClassLoader are used as
@@ -156,9 +174,11 @@
                         uint32_t method_idx,
                         DexCache* dex_cache,
                         ClassLoader* class_loader,
-                        bool is_direct);
+                        bool is_direct)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* ResolveMethod(uint32_t method_idx, const Method* referrer, bool is_direct) {
+  Method* ResolveMethod(uint32_t method_idx, const Method* referrer, bool is_direct)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* resolved_method = referrer->GetDexCacheResolvedMethods()->Get(method_idx);
     if (UNLIKELY(resolved_method == NULL || resolved_method->IsRuntimeMethod())) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -170,7 +190,8 @@
     return resolved_method;
   }
 
-  Field* ResolveField(uint32_t field_idx, const Method* referrer, bool is_static) {
+  Field* ResolveField(uint32_t field_idx, const Method* referrer, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Field* resolved_field =
         referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
     if (UNLIKELY(resolved_field == NULL)) {
@@ -192,7 +213,8 @@
                       uint32_t field_idx,
                       DexCache* dex_cache,
                       ClassLoader* class_loader,
-                      bool is_static);
+                      bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a field with a given ID from the DexFile, storing the
   // result in DexCache. The ClassLinker and ClassLoader are used as
@@ -201,89 +223,132 @@
   Field* ResolveFieldJLS(const DexFile& dex_file,
                          uint32_t field_idx,
                          DexCache* dex_cache,
-                         ClassLoader* class_loader);
+                         ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get shorty from method index without resolution. Used to do handlerization.
-  const char* MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length);
+  const char* MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Returns true on success, false if there's an exception pending.
   // can_run_clinit=false allows the compiler to attempt to init a class,
   // given the restriction that no <clinit> execution is possible.
-  bool EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields);
+  bool EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initializes classes that have instances in the image but that have
   // <clinit> methods so they could not be initialized by the compiler.
-  void RunRootClinits();
+  void RunRootClinits() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterDexFile(const DexFile& dex_file);
-  void RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache);
+  void RegisterDexFile(const DexFile& dex_file)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterOatFile(const OatFile& oat_file);
+  void RegisterOatFile(const OatFile& oat_file)
+      LOCKS_EXCLUDED(dex_lock_);
 
   const std::vector<const DexFile*>& GetBootClassPath() {
     return boot_class_path_;
   }
 
-  void VisitClasses(ClassVisitor* visitor, void* arg) const;
+  void VisitClasses(ClassVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
+  // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
+  // when calling the visitor.
+  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
-  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
+  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_, dex_lock_);
 
-  const DexFile& FindDexFile(const DexCache* dex_cache) const;
-  DexCache* FindDexCache(const DexFile& dex_file) const;
-  bool IsDexFileRegistered(const DexFile& dex_file) const;
-  void FixupDexCaches(Method* resolution_method) const;
+  const DexFile& FindDexFile(const DexCache* dex_cache) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  DexCache* FindDexCache(const DexFile& dex_file) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool IsDexFileRegistered(const DexFile& dex_file) const
+      LOCKS_EXCLUDED(dex_lock_);
+  void FixupDexCaches(Method* resolution_method) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Generate an oat file from a dex file
   bool GenerateOatFile(const std::string& dex_filename,
                        int oat_fd,
                        const std::string& oat_cache_filename);
 
-  const OatFile* FindOatFileFromOatLocation(const std::string& location);
+  const OatFile* FindOatFileFromOatLocation(const std::string& location)
+      LOCKS_EXCLUDED(dex_lock_);
+
+  const OatFile* FindOatFileFromOatLocationLocked(const std::string& location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
 
   // Finds the oat file for a dex location, generating the oat file if
   // it is missing or out of date. Returns the DexFile from within the
   // created oat file.
   const DexFile* FindOrCreateOatFileForDexLocation(const std::string& dex_location,
-                                                   const std::string& oat_location);
+                                                   const std::string& oat_location)
+      LOCKS_EXCLUDED(dex_lock_);
+  const DexFile* FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
+                                                         const std::string& oat_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
   // Find a DexFile within an OatFile given a DexFile location. Note
   // that this returns null if the location checksum of the DexFile
   // does not match the OatFile.
-  const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location);
+  const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
   // Returns true if oat file contains the dex file with the given location and checksum
   static bool VerifyOatFileChecksums(const OatFile* oat_file,
                                      const std::string& dex_location,
-                                     uint32_t dex_location_checksum);
+                                     uint32_t dex_location_checksum)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // TODO: replace this with multiple methods that allocate the correct managed type.
   template <class T>
-  ObjectArray<T>* AllocObjectArray(size_t length) {
+  ObjectArray<T>* AllocObjectArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ObjectArray<T>::Alloc(GetClassRoot(kObjectArrayClass), length);
   }
 
-  ObjectArray<Class>* AllocClassArray(size_t length) {
+  ObjectArray<Class>* AllocClassArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ObjectArray<Class>::Alloc(GetClassRoot(kClassArrayClass), length);
   }
 
-  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length);
+  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void VerifyClass(Class* klass);
+  void VerifyClass(Class* klass) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
-                               Class::Status& oat_file_class_status);
-  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass);
-  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* klass);
+                               Class::Status& oat_file_class_status)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
-                          ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws);
-  std::string GetDescriptorForProxy(const Class* proxy_class);
-  Method* FindMethodForProxy(const Class* proxy_class, const Method* proxy_method);
+                          ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  std::string GetDescriptorForProxy(const Class* proxy_class)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* FindMethodForProxy(const Class* proxy_class, const Method* proxy_method)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get the oat code for a method when its class isn't yet initialized
-  const void* GetOatCodeFor(const Method* method);
+  const void* GetOatCodeFor(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Relocate the OatFiles (ELF images)
-  void RelocateExecutable();
+  void RelocateExecutable() LOCKS_EXCLUDED(dex_lock_);
 
   pid_t GetClassesLockOwner(); // For SignalCatcher.
   pid_t GetDexLockOwner(); // For SignalCatcher.
@@ -291,47 +356,60 @@
  private:
   explicit ClassLinker(InternTable*);
 
-  const OatFile::OatMethod GetOatMethodFor(const Method* method);
+  const OatFile::OatMethod GetOatMethodFor(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initialize class linker by bootstraping from dex files
-  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path);
+  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initialize class linker from one or more images.
-  void InitFromImage();
-  OatFile* OpenOat(const ImageSpace* space);
-  static void InitFromImageCallback(Object* obj, void* arg);
+  void InitFromImage() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  OatFile* OpenOat(const ImageSpace* space)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void InitFromImageCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void FinishInit();
+  void FinishInit() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // For early bootstrapping by Init
-  Class* AllocClass(Class* java_lang_Class, size_t class_size);
+  Class* AllocClass(Class* java_lang_Class, size_t class_size)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Alloc* convenience functions to avoid needing to pass in Class*
   // values that are known to the ClassLinker such as
   // kObjectArrayClass and kJavaLangString etc.
-  Class* AllocClass(size_t class_size);
-  DexCache* AllocDexCache(const DexFile& dex_file);
-  Field* AllocField();
+  Class* AllocClass(size_t class_size) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  DexCache* AllocDexCache(const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Field* AllocField() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* AllocMethod() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* AllocMethod();
+  InterfaceEntry* AllocInterfaceEntry(Class* interface)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  InterfaceEntry* AllocInterfaceEntry(Class* interface);
-
-  Class* CreatePrimitiveClass(const char* descriptor, Primitive::Type type) {
+  Class* CreatePrimitiveClass(const char* descriptor, Primitive::Type type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return InitializePrimitiveClass(AllocClass(sizeof(Class)), descriptor, type);
   }
   Class* InitializePrimitiveClass(Class* primitive_class,
                                   const char* descriptor,
-                                  Primitive::Type type);
+                                  Primitive::Type type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
-  Class* CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader);
+  Class* CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void AppendToBootClassPath(const DexFile& dex_file);
-  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache);
+  void AppendToBootClassPath(const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
-                         Class* c, SafeMap<uint32_t, Field*>& field_map);
+                         Class* c, SafeMap<uint32_t, Field*>& field_map)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   size_t SizeOfClass(const DexFile& dex_file,
                      const DexFile::ClassDef& dex_class_def);
@@ -339,15 +417,18 @@
   void LoadClass(const DexFile& dex_file,
                  const DexFile::ClassDef& dex_class_def,
                  SirtRef<Class>& klass,
-                 ClassLoader* class_loader);
+                 ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
                  SirtRef<Field>& dst);
 
   void LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& dex_method,
-                  SirtRef<Class>& klass, SirtRef<Method>& dst);
+                  SirtRef<Class>& klass, SirtRef<Method>& dst)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void FixupStaticTrampolines(Class* klass);
+  void FixupStaticTrampolines(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the associated oat class for a dex_file and descriptor
   const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor);
@@ -355,68 +436,97 @@
   // Attempts to insert a class into a class table.  Returns NULL if
   // the class was inserted, otherwise returns an existing class with
   // the same descriptor and ClassLoader.
-  Class* InsertClass(const StringPiece& descriptor, Class* klass, bool image_class);
+  Class* InsertClass(const StringPiece& descriptor, Class* klass, bool image_class)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool IsDexFileRegisteredLocked(const DexFile& dex_file) const EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
-  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
 
-  bool InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics);
+  bool InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock);
-  bool ValidateSuperClassDescriptors(const Class* klass);
-  bool InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields);
+  bool ValidateSuperClassDescriptors(const Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   // Initialize static fields, returns true if fields were initialized.
-  bool InitializeStaticFields(Class* klass);
+  bool InitializeStaticFields(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
                                                 const Class* klass1,
-                                                const Class* klass2);
+                                                const Class* klass2)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsSameMethodSignatureInDifferentClassContexts(const Method* descriptor,
                                                      const Class* klass1,
-                                                     const Class* klass2);
+                                                     const Class* klass2)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkSuperClass(SirtRef<Class>& klass);
+  bool LinkSuperClass(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file);
+  bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkVirtualMethods(SirtRef<Class>& klass);
+  bool LinkVirtualMethods(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkStaticFields(SirtRef<Class>& klass);
-  bool LinkInstanceFields(SirtRef<Class>& klass);
-  bool LinkFields(SirtRef<Class>& klass, bool is_static);
+  bool LinkStaticFields(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool LinkInstanceFields(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool LinkFields(SirtRef<Class>& klass, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
-  void CreateReferenceInstanceOffsets(SirtRef<Class>& klass);
-  void CreateReferenceStaticOffsets(SirtRef<Class>& klass);
+  void CreateReferenceInstanceOffsets(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void CreateReferenceStaticOffsets(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
-                              uint32_t reference_offsets);
+                              uint32_t reference_offsets)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // For use by ImageWriter to find DexCaches for its roots
   const std::vector<DexCache*>& GetDexCaches() {
     return dex_caches_;
   }
 
-  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file);
-  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location);
-  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location);
+  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
+      LOCKS_EXCLUDED(dex_lock_);
+  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
   const DexFile* VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
                                                  const std::string& dex_location,
                                                  uint32_t dex_location_checksum)
-      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class);
-  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype);
+  Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   std::vector<const DexFile*> boot_class_path_;
 
-  mutable Mutex dex_lock_;
+  mutable Mutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   std::vector<const DexFile*> dex_files_ GUARDED_BY(dex_lock_);
   std::vector<DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
   std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
@@ -425,13 +535,14 @@
   // multimap from a string hash code of a class descriptor to
   // Class* instances. Results should be compared for a matching
   // Class::descriptor_ and Class::class_loader_.
-  mutable Mutex classes_lock_;
   typedef std::multimap<size_t, Class*> Table;
-  Table image_classes_  GUARDED_BY(classes_lock_);
-  Table classes_ GUARDED_BY(classes_lock_);
+  Table image_classes_  GUARDED_BY(GlobalSynchronization::classlinker_classes_lock_);
+  Table classes_ GUARDED_BY(GlobalSynchronization::classlinker_classes_lock_);
 
   Class* LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
-                           size_t hash, const Table& classes) EXCLUSIVE_LOCKS_REQUIRED(classes_lock_);
+                           size_t hash, const Table& classes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::classlinker_classes_lock_);
 
   // indexes into class_roots_.
   // needs to be kept in sync with class_roots_descriptors_.
@@ -447,8 +558,6 @@
     kJavaLangReflectMethod,
     kJavaLangReflectProxy,
     kJavaLangClassLoader,
-    kDalvikSystemBaseDexClassLoader,
-    kDalvikSystemPathClassLoader,
     kJavaLangThrowable,
     kJavaLangClassNotFoundException,
     kJavaLangStackTraceElement,
@@ -474,14 +583,16 @@
   };
   ObjectArray<Class>* class_roots_;
 
-  Class* GetClassRoot(ClassRoot class_root) {
+  Class* GetClassRoot(ClassRoot class_root)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(class_roots_ != NULL);
     Class* klass = class_roots_->Get(class_root);
     DCHECK(klass != NULL);
     return klass;
   }
 
-  void SetClassRoot(ClassRoot class_root, Class* klass);
+  void SetClassRoot(ClassRoot class_root, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   ObjectArray<Class>* GetClassRoots() {
     DCHECK(class_roots_ != NULL);
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index a7f9c66..1eb5e0d 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -29,7 +29,8 @@
 
 class ClassLinkerTest : public CommonTest {
  protected:
-  void AssertNonExistentClass(const std::string& descriptor) {
+  void AssertNonExistentClass(const std::string& descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     EXPECT_TRUE(class_linker_->FindSystemClass(descriptor.c_str()) == NULL);
     Thread* self = Thread::Current();
     EXPECT_TRUE(self->IsExceptionPending());
@@ -39,11 +40,13 @@
     EXPECT_TRUE(exception->InstanceOf(exception_class));
   }
 
-  void AssertPrimitiveClass(const std::string& descriptor) {
+  void AssertPrimitiveClass(const std::string& descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(descriptor.c_str()));
   }
 
-  void AssertPrimitiveClass(const std::string& descriptor, const Class* primitive) {
+  void AssertPrimitiveClass(const std::string& descriptor, const Class* primitive)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ClassHelper primitive_ch(primitive);
     ASSERT_TRUE(primitive != NULL);
     ASSERT_TRUE(primitive->GetClass() != NULL);
@@ -79,7 +82,8 @@
 
   void AssertArrayClass(const std::string& array_descriptor,
                         const std::string& component_type,
-                        ClassLoader* class_loader) {
+                        ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* array = class_linker_->FindClass(array_descriptor.c_str(), class_loader);
     ClassHelper array_component_ch(array->GetComponentType());
     EXPECT_STREQ(component_type.c_str(), array_component_ch.GetDescriptor());
@@ -87,7 +91,8 @@
     AssertArrayClass(array_descriptor, array);
   }
 
-  void AssertArrayClass(const std::string& array_descriptor, Class* array) {
+  void AssertArrayClass(const std::string& array_descriptor, Class* array)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ClassHelper kh(array);
     ASSERT_TRUE(array != NULL);
     ASSERT_TRUE(array->GetClass() != NULL);
@@ -130,7 +135,7 @@
     EXPECT_STREQ(kh.GetDescriptor(), "Ljava/io/Serializable;");
   }
 
-  void AssertMethod(Method* method) {
+  void AssertMethod(Method* method) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     MethodHelper mh(method);
     EXPECT_TRUE(method != NULL);
     EXPECT_TRUE(method->GetClass() != NULL);
@@ -151,7 +156,8 @@
               method->GetDexCacheInitializedStaticStorage());
   }
 
-  void AssertField(Class* klass, Field* field) {
+  void AssertField(Class* klass, Field* field)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     FieldHelper fh(field);
     EXPECT_TRUE(field != NULL);
     EXPECT_TRUE(field->GetClass() != NULL);
@@ -160,7 +166,8 @@
     EXPECT_TRUE(fh.GetType() != NULL);
   }
 
-  void AssertClass(const std::string& descriptor, Class* klass) {
+  void AssertClass(const std::string& descriptor, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ClassHelper kh(klass);
     EXPECT_STREQ(descriptor.c_str(), kh.GetDescriptor());
     if (descriptor == "Ljava/lang/Object;") {
@@ -283,7 +290,8 @@
               total_num_reference_instance_fields == 0);
   }
 
-  void AssertDexFileClass(ClassLoader* class_loader, const std::string& descriptor) {
+  void AssertDexFileClass(ClassLoader* class_loader, const std::string& descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ASSERT_TRUE(descriptor != NULL);
     Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
     ASSERT_TRUE(klass != NULL);
@@ -298,7 +306,8 @@
     }
   }
 
-  void AssertDexFile(const DexFile* dex, ClassLoader* class_loader) {
+  void AssertDexFile(const DexFile* dex, ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ASSERT_TRUE(dex != NULL);
 
     // Verify all the classes defined in this file
@@ -341,7 +350,7 @@
   std::string class_descriptor;
   std::vector<CheckOffset> offsets;
 
-  bool Check() {
+  bool Check() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* klass = Runtime::Current()->GetClassLinker()->FindSystemClass(class_descriptor.c_str());
     CHECK(klass != NULL) << class_descriptor;
 
@@ -549,21 +558,6 @@
   };
 };
 
-struct BaseDexClassLoaderOffsets : public CheckOffsets<BaseDexClassLoader> {
-  BaseDexClassLoaderOffsets()
-    : CheckOffsets<BaseDexClassLoader>(false, "Ldalvik/system/BaseDexClassLoader;") {
-    // alphabetical references
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(BaseDexClassLoader, original_library_path_), "originalLibraryPath"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(BaseDexClassLoader, original_path_),         "originalPath"));
-    offsets.push_back(CheckOffset(OFFSETOF_MEMBER(BaseDexClassLoader, path_list_),             "pathList"));
-  };
-};
-
-struct PathClassLoaderOffsets : public CheckOffsets<PathClassLoader> {
-  PathClassLoaderOffsets()
-    : CheckOffsets<PathClassLoader>(false, "Ldalvik/system/PathClassLoader;") {}
-};
-
 struct ProxyOffsets : public CheckOffsets<Proxy> {
   ProxyOffsets() : CheckOffsets<Proxy>(false, "Ljava/lang/reflect/Proxy;") {
     // alphabetical references
@@ -614,6 +608,7 @@
 // reorder the fields in the C++ class. Managed class fields are ordered by
 // ClassLinker::LinkFields.
 TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_TRUE(ObjectOffsets().Check());
   EXPECT_TRUE(ConstructorOffsets().Check());
   EXPECT_TRUE(FieldOffsets().Check());
@@ -623,8 +618,6 @@
   EXPECT_TRUE(ThrowableOffsets().Check());
   EXPECT_TRUE(StackTraceElementOffsets().Check());
   EXPECT_TRUE(ClassLoaderOffsets().Check());
-  EXPECT_TRUE(BaseDexClassLoaderOffsets().Check());
-  EXPECT_TRUE(PathClassLoaderOffsets().Check());
   EXPECT_TRUE(ProxyOffsets().Check());
 
   EXPECT_TRUE(ClassClassOffsets().Check());
@@ -634,12 +627,14 @@
 }
 
 TEST_F(ClassLinkerTest, FindClassNonexistent) {
+  ScopedObjectAccess soa(Thread::Current());
   AssertNonExistentClass("NoSuchClass;");
   AssertNonExistentClass("LNoSuchClass;");
 }
 
 TEST_F(ClassLinkerTest, FindClassNested) {
-  SirtRef<ClassLoader> class_loader(LoadDex("Nested"));
+  ScopedObjectAccess soa(Thread::Current());
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(LoadDex("Nested")));
 
   Class* outer = class_linker_->FindClass("LNested;", class_loader.get());
   ASSERT_TRUE(outer != NULL);
@@ -653,6 +648,7 @@
 }
 
 TEST_F(ClassLinkerTest, FindClass_Primitives) {
+  ScopedObjectAccess soa(Thread::Current());
   const std::string expected("BCDFIJSZV");
   for (int ch = 1; ch < 256; ++ch) {
     std::string descriptor;
@@ -666,6 +662,7 @@
 }
 
 TEST_F(ClassLinkerTest, FindClass) {
+  ScopedObjectAccess soa(Thread::Current());
   Class* JavaLangObject = class_linker_->FindSystemClass("Ljava/lang/Object;");
   ClassHelper kh(JavaLangObject);
   ASSERT_TRUE(JavaLangObject != NULL);
@@ -701,7 +698,7 @@
   EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
   EXPECT_EQ(0U, kh.NumDirectInterfaces());
 
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClass"));
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(LoadDex("MyClass")));
   AssertNonExistentClass("LMyClass;");
   Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader.get());
   kh.ChangeClass(MyClass);
@@ -746,12 +743,14 @@
 }
 
 TEST_F(ClassLinkerTest, LibCore) {
+  ScopedObjectAccess soa(Thread::Current());
   AssertDexFile(java_lang_dex_file_, NULL);
 }
 
 // The first reference array element must be a multiple of 4 bytes from the
 // start of the object
 TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
+  ScopedObjectAccess soa(Thread::Current());
   Class* array_class = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ObjectArray<String>* array = ObjectArray<String>::Alloc(array_class, 0);
   uint32_t array_offset = reinterpret_cast<uint32_t>(array);
@@ -765,6 +764,7 @@
 }
 
 TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<LongArray> long_array(LongArray::Alloc(0));
   EXPECT_EQ(class_linker_->FindSystemClass("[J"), long_array->GetClass());
   uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData());
@@ -796,6 +796,7 @@
 TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
   // Validate that the "value" field is always the 0th field in each of java.lang's box classes.
   // This lets UnboxPrimitive avoid searching for the field by name at runtime.
+  ScopedObjectAccess soa(Thread::Current());
   Class* c;
   c = class_linker_->FindClass("Ljava/lang/Boolean;", NULL);
   FieldHelper fh(c->GetIFields()->Get(0));
@@ -824,8 +825,9 @@
 }
 
 TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
-  SirtRef<ClassLoader> class_loader_1(LoadDex("MyClass"));
-  SirtRef<ClassLoader> class_loader_2(LoadDex("MyClass"));
+  ScopedObjectAccess soa(Thread::Current());
+  SirtRef<ClassLoader> class_loader_1(soa.Decode<ClassLoader*>(LoadDex("MyClass")));
+  SirtRef<ClassLoader> class_loader_2(soa.Decode<ClassLoader*>(LoadDex("MyClass")));
   Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1.get());
   Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2.get());
   EXPECT_TRUE(MyClass_1 != NULL);
@@ -834,7 +836,8 @@
 }
 
 TEST_F(ClassLinkerTest, StaticFields) {
-  SirtRef<ClassLoader> class_loader(LoadDex("Statics"));
+  ScopedObjectAccess soa(Thread::Current());
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(LoadDex("Statics")));
   Class* statics = class_linker_->FindClass("LStatics;", class_loader.get());
   class_linker_->EnsureInitialized(statics, true, true);
 
@@ -915,7 +918,8 @@
 }
 
 TEST_F(ClassLinkerTest, Interfaces) {
-  SirtRef<ClassLoader> class_loader(LoadDex("Interfaces"));
+  ScopedObjectAccess soa(Thread::Current());
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(LoadDex("Interfaces")));
   Class* I = class_linker_->FindClass("LInterfaces$I;", class_loader.get());
   Class* J = class_linker_->FindClass("LInterfaces$J;", class_loader.get());
   Class* K = class_linker_->FindClass("LInterfaces$K;", class_loader.get());
@@ -973,8 +977,10 @@
   // case 1, get the uninitialized storage from StaticsFromCode.<clinit>
   // case 2, get the initialized storage from StaticsFromCode.getS0
 
-  SirtRef<ClassLoader> class_loader(LoadDex("StaticsFromCode"));
-  const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(class_loader.get())[0];
+  ScopedObjectAccess soa(Thread::Current());
+  jobject jclass_loader = LoadDex("StaticsFromCode");
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
+  const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(jclass_loader)[0];
   CHECK(dex_file != NULL);
 
   Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
@@ -995,6 +1001,7 @@
 }
 
 TEST_F(ClassLinkerTest, FinalizableBit) {
+  ScopedObjectAccess soa(Thread::Current());
   Class* c;
 
   // Object has a finalize method, but we know it's empty.
@@ -1028,6 +1035,7 @@
 }
 
 TEST_F(ClassLinkerTest, ClassRootDescriptors) {
+  ScopedObjectAccess soa(Thread::Current());
   ClassHelper kh;
   for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
     Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
diff --git a/src/class_loader.cc b/src/class_loader.cc
deleted file mode 100644
index 3adb4ec..0000000
--- a/src/class_loader.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2011 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 "class_loader.h"
-
-#include "class_linker.h"
-#include "runtime.h"
-
-namespace art {
-
-// TODO: get global references for these
-Class* PathClassLoader::dalvik_system_PathClassLoader_ = NULL;
-
-PathClassLoader* PathClassLoader::AllocCompileTime(std::vector<const DexFile*>& dex_files) {
-  CHECK(!Runtime::Current()->IsStarted());
-  DCHECK(dalvik_system_PathClassLoader_ != NULL);
-  SirtRef<PathClassLoader> p(down_cast<PathClassLoader*>(dalvik_system_PathClassLoader_->AllocObject()));
-  Runtime::Current()->SetCompileTimeClassPath(p.get(), dex_files);
-  return p.get();
-}
-
-void PathClassLoader::SetClass(Class* dalvik_system_PathClassLoader) {
-  CHECK(dalvik_system_PathClassLoader_ == NULL);
-  CHECK(dalvik_system_PathClassLoader != NULL);
-  dalvik_system_PathClassLoader_ = dalvik_system_PathClassLoader;
-}
-
-void PathClassLoader::ResetClass() {
-  CHECK(dalvik_system_PathClassLoader_ != NULL);
-  dalvik_system_PathClassLoader_ = NULL;
-}
-
-}  // namespace art
diff --git a/src/class_loader.h b/src/class_loader.h
index 0e1148d..029c4a2 100644
--- a/src/class_loader.h
+++ b/src/class_loader.h
@@ -36,30 +36,6 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(ClassLoader);
 };
 
-// C++ mirror of dalvik.system.BaseDexClassLoader
-class MANAGED BaseDexClassLoader : public ClassLoader {
- private:
-  // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
-  String* original_library_path_;
-  String* original_path_;
-  Object* path_list_;
-
-  friend struct BaseDexClassLoaderOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(BaseDexClassLoader);
-};
-
-// C++ mirror of dalvik.system.PathClassLoader
-class MANAGED PathClassLoader : public BaseDexClassLoader {
- public:
-  static PathClassLoader* AllocCompileTime(std::vector<const DexFile*>& dex_files);
-  static void SetClass(Class* dalvik_system_PathClassLoader);
-  static void ResetClass();
- private:
-  static Class* dalvik_system_PathClassLoader_;
-  friend struct PathClassLoaderOffsets;  // for verifying offset information
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PathClassLoader);
-};
-
 }  // namespace art
 
 #endif  // ART_SRC_CLASS_LOADER_H_
diff --git a/src/common_test.h b/src/common_test.h
index 58d0219..41dc76c 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -33,12 +33,15 @@
 #include "object_utils.h"
 #include "os.h"
 #include "runtime.h"
+#include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "stl_util.h"
 #include "stringprintf.h"
 #include "thread.h"
 #include "unicode/uclean.h"
 #include "unicode/uvernum.h"
 #include "UniquePtr.h"
+#include "well_known_classes.h"
 
 namespace art {
 
@@ -206,7 +209,7 @@
                                 );
   }
 
-  void MakeExecutable(Method* method) {
+  void MakeExecutable(Method* method) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(method != NULL);
 
     MethodHelper mh(method);
@@ -328,7 +331,17 @@
     options.push_back(std::make_pair("-Xcheck:jni", reinterpret_cast<void*>(NULL)));
     options.push_back(std::make_pair(min_heap_string.c_str(), reinterpret_cast<void*>(NULL)));
     options.push_back(std::make_pair(max_heap_string.c_str(), reinterpret_cast<void*>(NULL)));
-    runtime_.reset(Runtime::Create(options, false));
+    if(!Runtime::Create(options, false)) {
+      LOG(FATAL) << "Failed to create runtime";
+      return;
+    }
+    runtime_.reset(Runtime::Current());
+    // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
+    // give it away now and then switch to a more managable ScopedObjectAccess.
+    Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+    // Whilst we're in native take the opportunity to initialize well known classes.
+    WellKnownClasses::InitClasses(Thread::Current()->GetJniEnv());
+    ScopedObjectAccess soa(Thread::Current());
     ASSERT_TRUE(runtime_.get() != NULL);
     class_linker_ = runtime_->GetClassLinker();
 
@@ -362,7 +375,7 @@
     compiler_.reset(new Compiler(instruction_set, true, 2, false, image_classes_.get(),
                                  true, true));
 
-    Runtime::Current()->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
+    runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
   }
 
   virtual void TearDown() {
@@ -436,16 +449,20 @@
     return dex_file;
   }
 
-  ClassLoader* LoadDex(const char* dex_name) {
+  jobject LoadDex(const char* dex_name)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile* dex_file = OpenTestDexFile(dex_name);
     CHECK(dex_file != NULL);
     class_linker_->RegisterDexFile(*dex_file);
     std::vector<const DexFile*> class_path;
     class_path.push_back(dex_file);
-    SirtRef<ClassLoader> class_loader(PathClassLoader::AllocCompileTime(class_path));
-    CHECK(class_loader.get() != NULL);
-    Thread::Current()->SetClassLoaderOverride(class_loader.get());
-    return class_loader.get();
+    ScopedObjectAccessUnchecked soa(Thread::Current());
+    ScopedLocalRef<jobject> class_loader_local(soa.Env(),
+        soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
+    jobject class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
+    soa.Self()->SetClassLoaderOverride(soa.Decode<ClassLoader*>(class_loader_local.get()));
+    Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path);
+    return class_loader;
   }
 
   void CompileClass(ClassLoader* class_loader, const char* class_name) {
@@ -460,7 +477,7 @@
     }
   }
 
-  void CompileMethod(Method* method) {
+  void CompileMethod(Method* method) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(method != NULL);
     compiler_->CompileOne(method);
     MakeExecutable(method);
@@ -471,7 +488,8 @@
   void CompileDirectMethod(ClassLoader* class_loader,
                            const char* class_name,
                            const char* method_name,
-                           const char* signature) {
+                           const char* signature)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::string class_descriptor(DotToDescriptor(class_name));
     Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
     CHECK(klass != NULL) << "Class not found " << class_name;
@@ -484,7 +502,8 @@
   void CompileVirtualMethod(ClassLoader* class_loader,
                             const char* class_name,
                             const char* method_name,
-                            const char* signature) {
+                            const char* signature)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::string class_descriptor(DotToDescriptor(class_name));
     Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
     CHECK(klass != NULL) << "Class not found " << class_name;
diff --git a/src/compiler.cc b/src/compiler.cc
index ceb9d11..bcbb77d 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -27,9 +27,12 @@
 #include "jni_internal.h"
 #include "oat_compilation_unit.h"
 #include "oat_file.h"
+#include "oat/runtime/stub.h"
 #include "object_utils.h"
 #include "runtime.h"
 #include "space.h"
+#include "scoped_thread_state_change.h"
+#include "ScopedLocalRef.h"
 #include "stl_util.h"
 #include "timing_logger.h"
 #include "verifier/method_verifier.h"
@@ -40,17 +43,6 @@
 
 namespace art {
 
-namespace arm {
-  ByteArray* CreateAbstractMethodErrorStub();
-  ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type);
-  ByteArray* CreateJniDlsymLookupStub();
-}
-namespace x86 {
-  ByteArray* CreateAbstractMethodErrorStub();
-  ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type);
-  ByteArray* CreateJniDlsymLookupStub();
-}
-
 static double Percentage(size_t x, size_t y) {
   return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
 }
@@ -311,6 +303,7 @@
       image_(image),
       thread_count_(thread_count),
       support_debugging_(support_debugging),
+      start_ns_(0),
       stats_(new AOTCompilationStats),
       dump_stats_(dump_stats),
       dump_timings_(dump_timings),
@@ -435,7 +428,7 @@
   }
 }
 
-void Compiler::CompileAll(ClassLoader* class_loader,
+void Compiler::CompileAll(jobject class_loader,
                           const std::vector<const DexFile*>& dex_files) {
   DCHECK(!Runtime::Current()->IsStarted());
 
@@ -464,27 +457,41 @@
 
 void Compiler::CompileOne(const Method* method) {
   DCHECK(!Runtime::Current()->IsStarted());
+  Thread* self = Thread::Current();
+  jobject class_loader;
+  const DexCache* dex_cache;
+  const DexFile* dex_file;
+  {
+    ScopedObjectAccessUnchecked soa(self);
+    ScopedLocalRef<jobject>
+      local_class_loader(soa.Env(),
+                    soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
+    class_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
+    // Find the dex_file
+    dex_cache = method->GetDeclaringClass()->GetDexCache();
+    dex_file = &Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
+  }
+  self->TransitionFromRunnableToSuspended(kNative);
 
-  ClassLoader* class_loader = method->GetDeclaringClass()->GetClassLoader();
-
-  // Find the dex_file
-  const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
-  const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
   std::vector<const DexFile*> dex_files;
-  dex_files.push_back(&dex_file);
+  dex_files.push_back(dex_file);
 
   TimingLogger timings("CompileOne");
   PreCompile(class_loader, dex_files, timings);
 
   uint32_t method_idx = method->GetDexMethodIndex();
-  const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
-  CompileMethod(code_item, method->GetAccessFlags(), method_idx, class_loader, dex_file);
+  const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
+  CompileMethod(code_item, method->GetAccessFlags(), method_idx, class_loader, *dex_file);
 
   PostCompile(class_loader, dex_files);
+
+  self->GetJniEnv()->DeleteGlobalRef(class_loader);
+
+  self->TransitionFromSuspendedToRunnable();
 }
 
-void Compiler::Resolve(ClassLoader* class_loader,
-                       const std::vector<const DexFile*>& dex_files, TimingLogger& timings) {
+void Compiler::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                       TimingLogger& timings) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -492,8 +499,8 @@
   }
 }
 
-void Compiler::PreCompile(ClassLoader* class_loader,
-                          const std::vector<const DexFile*>& dex_files, TimingLogger& timings) {
+void Compiler::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                          TimingLogger& timings) {
   Resolve(class_loader, dex_files, timings);
 
   Verify(class_loader, dex_files);
@@ -503,8 +510,7 @@
   timings.AddSplit("PreCompile.InitializeClassesWithoutClinit");
 }
 
-void Compiler::PostCompile(ClassLoader* class_loader,
-                           const std::vector<const DexFile*>& dex_files) {
+void Compiler::PostCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
   SetGcMaps(class_loader, dex_files);
 }
 
@@ -515,8 +521,10 @@
   return image_classes_->find(descriptor) != image_classes_->end();
 }
 
-bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache,
+bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
                                                 uint32_t type_idx) {
+  ScopedObjectAccess soa(Thread::Current());
+  DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
   if (!IsImage()) {
     stats_->TypeNotInDexCache();
     return false;
@@ -535,14 +543,19 @@
   return result;
 }
 
-bool Compiler::CanAssumeStringIsPresentInDexCache(const DexCache* dex_cache,
+bool Compiler::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
                                                   uint32_t string_idx) {
   // TODO: Add support for loading strings referenced by image_classes_
   // See also Compiler::ResolveDexFile
 
   // The following is a test saying that if we're building the image without a restricted set of
   // image classes then we can assume the string is present in the dex cache if it is there now
-  bool result = IsImage() && image_classes_ == NULL && dex_cache->GetResolvedString(string_idx) != NULL;
+  bool result = IsImage() && image_classes_ == NULL;
+  if (result) {
+    ScopedObjectAccess soa(Thread::Current());
+    DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+    result = dex_cache->GetResolvedString(string_idx) != NULL;
+  }
   if (result) {
     stats_->StringInDexCache();
   } else {
@@ -551,8 +564,10 @@
   return result;
 }
 
-bool Compiler::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexCache* dex_cache,
-                                          const DexFile& dex_file, uint32_t type_idx) {
+bool Compiler::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
+                                          uint32_t type_idx) {
+  ScopedObjectAccess soa(Thread::Current());
+  DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
   // Get type from dex cache assuming it was populated by the verifier
   Class* resolved_class = dex_cache->GetResolvedType(type_idx);
   if (resolved_class == NULL) {
@@ -577,9 +592,10 @@
 }
 
 bool Compiler::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
-                                                      const DexCache* dex_cache,
                                                       const DexFile& dex_file,
                                                       uint32_t type_idx) {
+  ScopedObjectAccess soa(Thread::Current());
+  DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
   // Get type from dex cache assuming it was populated by the verifier.
   Class* resolved_class = dex_cache->GetResolvedType(type_idx);
   if (resolved_class == NULL) {
@@ -603,36 +619,44 @@
   return result;
 }
 
-static Class* ComputeReferrerClass(OatCompilationUnit* mUnit) {
-  const DexFile::MethodId& referrer_method_id =
-    mUnit->dex_file_->GetMethodId(mUnit->method_idx_);
-
-  return mUnit->class_linker_->ResolveType(
-    *mUnit->dex_file_, referrer_method_id.class_idx_,
-    mUnit->dex_cache_, mUnit->class_loader_);
+static Class* ComputeReferrerClass(ScopedObjectAccess& soa,
+                                   OatCompilationUnit* mUnit)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+  const DexFile::MethodId& referrer_method_id = mUnit->dex_file_->GetMethodId(mUnit->method_idx_);
+  return mUnit->class_linker_->ResolveType(*mUnit->dex_file_, referrer_method_id.class_idx_,
+                                           dex_cache, class_loader);
 }
 
-static Field* ComputeReferrerField(OatCompilationUnit* mUnit, uint32_t field_idx) {
-  return mUnit->class_linker_->ResolveField(
-    *mUnit->dex_file_, field_idx, mUnit->dex_cache_,
-    mUnit->class_loader_, false);
+static Field* ComputeReferrerField(ScopedObjectAccess& soa,
+                                   OatCompilationUnit* mUnit, uint32_t field_idx)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+  return mUnit->class_linker_->ResolveField(*mUnit->dex_file_, field_idx, dex_cache,
+                                            class_loader, false);
 }
 
-static Method* ComputeReferrerMethod(OatCompilationUnit* mUnit, uint32_t method_idx) {
-  return mUnit->class_linker_->ResolveMethod(
-    *mUnit->dex_file_, method_idx, mUnit->dex_cache_,
-    mUnit->class_loader_, true);
+static Method* ComputeReferrerMethod(ScopedObjectAccess& soa,
+                                     OatCompilationUnit* mUnit, uint32_t method_idx)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+  return mUnit->class_linker_->ResolveMethod(*mUnit->dex_file_, method_idx, dex_cache,
+                                             class_loader, true);
 }
 
 bool Compiler::ComputeInstanceFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
                                         int& field_offset, bool& is_volatile, bool is_put) {
+  ScopedObjectAccess soa(Thread::Current());
   // Conservative defaults
   field_offset = -1;
   is_volatile = true;
   // Try to resolve field
-  Field* resolved_field = ComputeReferrerField(mUnit, field_idx);
+  Field* resolved_field = ComputeReferrerField(soa, mUnit, field_idx);
   if (resolved_field != NULL) {
-    Class* referrer_class = ComputeReferrerClass(mUnit);
+    Class* referrer_class = ComputeReferrerClass(soa, mUnit);
     if (referrer_class != NULL) {
       Class* fields_class = resolved_field->GetDeclaringClass();
       bool access_ok = referrer_class->CanAccess(fields_class) &&
@@ -661,9 +685,8 @@
     }
   }
   // Clean up any exception left by field/type resolution
-  Thread* thread = Thread::Current();
-  if (thread->IsExceptionPending()) {
-      thread->ClearException();
+  if (soa.Self()->IsExceptionPending()) {
+    soa.Self()->ClearException();
   }
   stats_->UnresolvedInstanceField();
   return false;  // Incomplete knowledge needs slow path.
@@ -672,16 +695,17 @@
 bool Compiler::ComputeStaticFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
                                       int& field_offset, int& ssb_index,
                                       bool& is_referrers_class, bool& is_volatile, bool is_put) {
+  ScopedObjectAccess soa(Thread::Current());
   // Conservative defaults
   field_offset = -1;
   ssb_index = -1;
   is_referrers_class = false;
   is_volatile = true;
   // Try to resolve field
-  Field* resolved_field = ComputeReferrerField(mUnit, field_idx);
+  Field* resolved_field = ComputeReferrerField(soa, mUnit, field_idx);
   if (resolved_field != NULL) {
     DCHECK(resolved_field->IsStatic());
-    Class* referrer_class = ComputeReferrerClass(mUnit);
+    Class* referrer_class = ComputeReferrerClass(soa, mUnit);
     if (referrer_class != NULL) {
       Class* fields_class = resolved_field->GetDeclaringClass();
       if (fields_class == referrer_class) {
@@ -714,7 +738,8 @@
           // in its static storage base (which may fail if it doesn't have a slot for it)
           // TODO: for images we can elide the static storage base null check
           // if we know there's a non-null entry in the image
-          if (fields_class->GetDexCache() == mUnit->dex_cache_) {
+          DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+          if (fields_class->GetDexCache() == dex_cache) {
             // common case where the dex cache of both the referrer and the field are the same,
             // no need to search the dex file
             ssb_index = fields_class->GetDexTypeIndex();
@@ -745,9 +770,8 @@
     }
   }
   // Clean up any exception left by field/type resolution
-  Thread* thread = Thread::Current();
-  if (thread->IsExceptionPending()) {
-      thread->ClearException();
+  if (soa.Self()->IsExceptionPending()) {
+    soa.Self()->ClearException();
   }
   stats_->UnresolvedStaticField();
   return false;  // Incomplete knowledge needs slow path.
@@ -793,12 +817,13 @@
 bool Compiler::ComputeInvokeInfo(uint32_t method_idx, OatCompilationUnit* mUnit, InvokeType& type,
                                  int& vtable_idx, uintptr_t& direct_code,
                                  uintptr_t& direct_method) {
+  ScopedObjectAccess soa(Thread::Current());
   vtable_idx = -1;
   direct_code = 0;
   direct_method = 0;
-  Method* resolved_method = ComputeReferrerMethod(mUnit, method_idx);
+  Method* resolved_method = ComputeReferrerMethod(soa, mUnit, method_idx);
   if (resolved_method != NULL) {
-    Class* referrer_class = ComputeReferrerClass(mUnit);
+    Class* referrer_class = ComputeReferrerClass(soa, mUnit);
     if (referrer_class != NULL) {
       Class* methods_class = resolved_method->GetDeclaringClass();
       if (!referrer_class->CanAccess(methods_class) ||
@@ -847,40 +872,35 @@
     }
   }
   // Clean up any exception left by method/type resolution
-  Thread* thread = Thread::Current();
-  if (thread->IsExceptionPending()) {
-      thread->ClearException();
+  if (soa.Self()->IsExceptionPending()) {
+      soa.Self()->ClearException();
   }
   stats_->UnresolvedMethod(type);
   return false;  // Incomplete knowledge needs slow path.
 }
 
-void Compiler::AddCodePatch(DexCache* dex_cache,
-                            const DexFile* dex_file,
+void Compiler::AddCodePatch(const DexFile* dex_file,
                             uint32_t referrer_method_idx,
                             uint32_t referrer_access_flags,
                             uint32_t target_method_idx,
                             bool target_is_direct,
                             size_t literal_offset) {
   MutexLock mu(compiled_methods_lock_);
-  code_to_patch_.push_back(new PatchInformation(dex_cache,
-                                                dex_file,
+  code_to_patch_.push_back(new PatchInformation(dex_file,
                                                 referrer_method_idx,
                                                 referrer_access_flags,
                                                 target_method_idx,
                                                 target_is_direct,
                                                 literal_offset));
 }
-void Compiler::AddMethodPatch(DexCache* dex_cache,
-                              const DexFile* dex_file,
+void Compiler::AddMethodPatch(const DexFile* dex_file,
                               uint32_t referrer_method_idx,
                               uint32_t referrer_access_flags,
                               uint32_t target_method_idx,
                               bool target_is_direct,
                               size_t literal_offset) {
   MutexLock mu(compiled_methods_lock_);
-  methods_to_patch_.push_back(new PatchInformation(dex_cache,
-                                                   dex_file,
+  methods_to_patch_.push_back(new PatchInformation(dex_file,
                                                    referrer_method_idx,
                                                    referrer_access_flags,
                                                    target_method_idx,
@@ -888,73 +908,47 @@
                                                    literal_offset));
 }
 
-// Return true if the class should be skipped during compilation. We
-// never skip classes in the boot class loader. However, if we have a
-// non-boot class loader and we can resolve the class in the boot
-// class loader, we do skip the class. This happens if an app bundles
-// classes found in the boot classpath. Since at runtime we will
-// select the class from the boot classpath, do not attempt to resolve
-// or compile it now.
-static bool SkipClass(ClassLoader* class_loader,
-                      const DexFile& dex_file,
-                      const DexFile::ClassDef& class_def) {
-  if (class_loader == NULL) {
-    return false;
-  }
-  const char* descriptor = dex_file.GetClassDescriptor(class_def);
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  Class* klass = class_linker->FindClass(descriptor, NULL);
-  if (klass == NULL) {
-    Thread* self = Thread::Current();
-    CHECK(self->IsExceptionPending());
-    self->ClearException();
-    return false;
-  }
-  return true;
-}
-
 class CompilationContext {
  public:
   CompilationContext(ClassLinker* class_linker,
-          ClassLoader* class_loader,
+          jobject class_loader,
           Compiler* compiler,
-          DexCache* dex_cache,
           const DexFile* dex_file)
     : class_linker_(class_linker),
       class_loader_(class_loader),
       compiler_(compiler),
-      dex_cache_(dex_cache),
       dex_file_(dex_file) {}
 
-  ClassLinker* GetClassLinker() {
+  ClassLinker* GetClassLinker() const {
     CHECK(class_linker_ != NULL);
     return class_linker_;
   }
-  ClassLoader* GetClassLoader() {
+
+  jobject GetClassLoader() const {
     return class_loader_;
   }
-  Compiler* GetCompiler() {
+
+  Compiler* GetCompiler() const {
     CHECK(compiler_ != NULL);
     return compiler_;
   }
-  DexCache* GetDexCache() {
-    CHECK(dex_cache_ != NULL);
-    return dex_cache_;
-  }
-  const DexFile* GetDexFile() {
+
+  const DexFile* GetDexFile() const {
     CHECK(dex_file_ != NULL);
     return dex_file_;
   }
 
  private:
-  ClassLinker* class_linker_;
-  ClassLoader* class_loader_;
-  Compiler* compiler_;
-  DexCache* dex_cache_;
-  const DexFile* dex_file_;
+  ClassLinker* const class_linker_;
+  const jobject class_loader_;
+  Compiler* const compiler_;
+  const DexFile* const dex_file_;
 };
 
-typedef void Callback(CompilationContext* context, size_t index);
+typedef void Callback(const CompilationContext* context, size_t index);
+
+static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
+                   size_t thread_count);
 
 class WorkerThread {
  public:
@@ -977,48 +971,49 @@
   }
 
  private:
-  static void* Go(void* arg) {
+  static void* Go(void* arg) LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     WorkerThread* worker = reinterpret_cast<WorkerThread*>(arg);
     Runtime* runtime = Runtime::Current();
     if (worker->spawn_) {
       runtime->AttachCurrentThread("Compiler Worker", true, NULL);
     }
-    Thread::Current()->SetState(kRunnable);
     worker->Run();
     if (worker->spawn_) {
-      Thread::Current()->SetState(kNative);
       runtime->DetachCurrentThread();
     }
     return NULL;
   }
 
-  void Go() {
+  void Go() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     Go(this);
   }
 
-  void Run() {
+  void Run() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     Thread* self = Thread::Current();
     for (size_t i = begin_; i < end_; i += stripe_) {
       callback_(context_, i);
-      CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException()) << " " << i;
+      self->AssertNoPendingException();
     }
   }
 
   pthread_t pthread_;
-  bool spawn_;
+  // Was this thread spawned or is it the main thread?
+  const bool spawn_;
 
-  CompilationContext* context_;
-  size_t begin_;
-  size_t end_;
-  Callback* callback_;
-  size_t stripe_;
+  const CompilationContext* const context_;
+  const size_t begin_;
+  const size_t end_;
+  const Callback* callback_;
+  const size_t stripe_;
 
   friend void ForAll(CompilationContext*, size_t, size_t, Callback, size_t);
 };
 
-void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback, size_t thread_count) {
+static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
+                   size_t thread_count)
+    LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
   Thread* self = Thread::Current();
-  CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+  self->AssertNoPendingException();
   CHECK_GT(thread_count, 0U);
 
   std::vector<WorkerThread*> threads;
@@ -1027,12 +1022,45 @@
   }
   threads[0]->Go();
 
-  // Switch to kVmWait while we're blocked waiting for the other threads to finish.
-  ScopedThreadStateChange tsc(self, kVmWait);
+  // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
+  // thread destructor's called below perform join).
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_NE(self->GetState(), kRunnable);
+  }
   STLDeleteElements(&threads);
 }
 
-static void ResolveClassFieldsAndMethods(CompilationContext* context, size_t class_def_index) {
+// Return true if the class should be skipped during compilation. We
+// never skip classes in the boot class loader. However, if we have a
+// non-boot class loader and we can resolve the class in the boot
+// class loader, we do skip the class. This happens if an app bundles
+// classes found in the boot classpath. Since at runtime we will
+// select the class from the boot classpath, do not attempt to resolve
+// or compile it now.
+static bool SkipClass(ClassLoader* class_loader,
+                      const DexFile& dex_file,
+                      const DexFile::ClassDef& class_def)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (class_loader == NULL) {
+    return false;
+  }
+  const char* descriptor = dex_file.GetClassDescriptor(class_def);
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  Class* klass = class_linker->FindClass(descriptor, NULL);
+  if (klass == NULL) {
+    Thread* self = Thread::Current();
+    CHECK(self->IsExceptionPending());
+    self->ClearException();
+    return false;
+  }
+  return true;
+}
+
+static void ResolveClassFieldsAndMethods(const CompilationContext* context, size_t class_def_index)
+    LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
+  ScopedObjectAccess soa(Thread::Current());
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
   const DexFile& dex_file = *context->GetDexFile();
 
   // Method and Field are the worst. We can't resolve without either
@@ -1043,7 +1071,7 @@
   // definitions, since many of them many never be referenced by
   // generated code.
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-  if (SkipClass(context->GetClassLoader(), dex_file, class_def)) {
+  if (SkipClass(class_loader, dex_file, class_def)) {
     return;
   }
 
@@ -1061,7 +1089,7 @@
   ClassDataItemIterator it(dex_file, class_data);
   while (it.HasNextStaticField()) {
     Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
-                                              context->GetClassLoader(), true);
+                                              class_loader, true);
     if (field == NULL) {
       CHECK(self->IsExceptionPending());
       self->ClearException();
@@ -1070,7 +1098,7 @@
   }
   while (it.HasNextInstanceField()) {
     Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
-                                              context->GetClassLoader(), false);
+                                              class_loader, false);
     if (field == NULL) {
       CHECK(self->IsExceptionPending());
       self->ClearException();
@@ -1079,7 +1107,7 @@
   }
   while (it.HasNextDirectMethod()) {
     Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
-                                                 context->GetClassLoader(), true);
+                                                 class_loader, true);
     if (method == NULL) {
       CHECK(self->IsExceptionPending());
       self->ClearException();
@@ -1088,7 +1116,7 @@
   }
   while (it.HasNextVirtualMethod()) {
     Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
-                                                 context->GetClassLoader(), false);
+                                                 class_loader, false);
     if (method == NULL) {
       CHECK(self->IsExceptionPending());
       self->ClearException();
@@ -1098,43 +1126,38 @@
   DCHECK(!it.HasNext());
 }
 
-static void ResolveType(CompilationContext* context, size_t type_idx) {
+static void ResolveType(const CompilationContext* context, size_t type_idx)
+    LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
   // Class derived values are more complicated, they require the linker and loader.
-  Thread* self = Thread::Current();
-  Class* klass = context->GetClassLinker()->ResolveType(*context->GetDexFile(),
-                                                        type_idx,
-                                                        context->GetDexCache(),
-                                                        context->GetClassLoader());
+  ScopedObjectAccess soa(Thread::Current());
+  ClassLinker* class_linker = context->GetClassLinker();
+  const DexFile& dex_file = *context->GetDexFile();
+  DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
+  Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
+
   if (klass == NULL) {
-    CHECK(self->IsExceptionPending());
+    CHECK(soa.Self()->IsExceptionPending());
     Thread::Current()->ClearException();
   }
 }
 
-void Compiler::ResolveDexFile(ClassLoader* class_loader, const DexFile& dex_file, TimingLogger& timings) {
+void Compiler::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
+                              TimingLogger& timings) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  DexCache* dex_cache = class_linker->FindDexCache(dex_file);
 
-  // Strings are easy in that they always are simply resolved to literals in the same file
-  if (image_ && image_classes_ == NULL) {
-    // TODO: Add support for loading strings referenced by image_classes_
-    // See also Compiler::CanAssumeTypeIsPresentInDexCache.
-    for (size_t string_idx = 0; string_idx < dex_cache->NumStrings(); string_idx++) {
-      class_linker->ResolveString(dex_file, string_idx, dex_cache);
-    }
-    timings.AddSplit("Resolve " + dex_file.GetLocation() + " Strings");
-  }
+  // TODO: we could resolve strings here, although the string table is largely filled with class
+  //       and method names.
 
-  CompilationContext context(class_linker, class_loader, this, dex_cache, &dex_file);
-  ForAll(&context, 0, dex_cache->NumResolvedTypes(), ResolveType, thread_count_);
+  CompilationContext context(class_linker, class_loader, this, &dex_file);
+  ForAll(&context, 0, dex_file.NumTypeIds(), ResolveType, thread_count_);
   timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
 
   ForAll(&context, 0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
   timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
 }
 
-void Compiler::Verify(ClassLoader* class_loader,
-                      const std::vector<const DexFile*>& dex_files) {
+void Compiler::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1142,10 +1165,14 @@
   }
 }
 
-static void VerifyClass(CompilationContext* context, size_t class_def_index) {
+static void VerifyClass(const CompilationContext* context, size_t class_def_index)
+    LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
+  ScopedObjectAccess soa(Thread::Current());
   const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
   const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
-  Class* klass = context->GetClassLinker()->FindClass(descriptor, context->GetClassLoader());
+  Class* klass =
+      context->GetClassLinker()->FindClass(descriptor,
+                                           soa.Decode<ClassLoader*>(context->GetClassLoader()));
   if (klass == NULL) {
     Thread* self = Thread::Current();
     CHECK(self->IsExceptionPending());
@@ -1156,9 +1183,13 @@
      * This is to ensure the class is structurally sound for compilation. An unsound class
      * will be rejected by the verifier and later skipped during compilation in the compiler.
      */
+    DexCache* dex_cache =  context->GetClassLinker()->FindDexCache(*context->GetDexFile());
     std::string error_msg;
-    if (verifier::MethodVerifier::VerifyClass(context->GetDexFile(), context->GetDexCache(),
-        context->GetClassLoader(), class_def_index, error_msg) == verifier::MethodVerifier::kHardFailure) {
+    if (verifier::MethodVerifier::VerifyClass(context->GetDexFile(),
+                                              dex_cache,
+                                              soa.Decode<ClassLoader*>(context->GetClassLoader()),
+                                              class_def_index, error_msg) ==
+                                                  verifier::MethodVerifier::kHardFailure) {
       const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
       LOG(ERROR) << "Verification failed on class "
                  << PrettyDescriptor(context->GetDexFile()->GetClassDescriptor(class_def))
@@ -1173,24 +1204,32 @@
     // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
     CHECK(Thread::Current()->IsExceptionPending());
     Thread::Current()->ClearException();
-    art::Compiler::ClassReference ref(context->GetDexFile(), class_def_index);
   }
 
   CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous()) << PrettyClass(klass);
   CHECK(!Thread::Current()->IsExceptionPending()) << PrettyTypeOf(Thread::Current()->GetException());
 }
 
-void Compiler::VerifyDexFile(ClassLoader* class_loader, const DexFile& dex_file) {
+void Compiler::VerifyDexFile(jobject class_loader, const DexFile& dex_file) {
   dex_file.ChangePermissions(PROT_READ | PROT_WRITE);
 
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  CompilationContext context(class_linker, class_loader, this, class_linker->FindDexCache(dex_file), &dex_file);
+  jobject dex_cache;
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    ScopedLocalRef<jobject>
+        dex_cache_local(soa.Env(),
+                        soa.AddLocalReference<jobject>(class_linker->FindDexCache(dex_file)));
+    dex_cache = soa.Env()->NewGlobalRef(dex_cache_local.get());
+  }
+  CompilationContext context(class_linker, class_loader, this, &dex_file);
   ForAll(&context, 0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
 
+  Thread::Current()->GetJniEnv()->DeleteGlobalRef(dex_cache);
   dex_file.ChangePermissions(PROT_READ);
 }
 
-void Compiler::InitializeClassesWithoutClinit(ClassLoader* class_loader,
+void Compiler::InitializeClassesWithoutClinit(jobject class_loader,
                                               const std::vector<const DexFile*>& dex_files) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
@@ -1199,7 +1238,9 @@
   }
 }
 
-void Compiler::InitializeClassesWithoutClinit(ClassLoader* class_loader, const DexFile& dex_file) {
+void Compiler::InitializeClassesWithoutClinit(jobject jni_class_loader, const DexFile& dex_file) {
+  ScopedObjectAccess soa(Thread::Current());
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(jni_class_loader);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
     const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
@@ -1216,9 +1257,9 @@
       // record the final class status if necessary
       Class::Status status = klass->GetStatus();
       ClassReference ref(&dex_file, class_def_index);
-      MutexLock mu(compiled_classes_lock_);
       CompiledClass* compiled_class = GetCompiledClass(ref);
       if (compiled_class == NULL) {
+        MutexLock mu(compiled_classes_lock_);
         compiled_class = new CompiledClass(status);
         compiled_classes_.Put(ref, compiled_class);
       } else {
@@ -1274,10 +1315,11 @@
     if (worker->spawn_) {
       runtime->AttachCurrentThread("Compiler Worker", true, NULL);
     }
-    Thread::Current()->SetState(kRunnable);
-    worker->Run();
+    {
+      ScopedObjectAccess soa(Thread::Current());
+      worker->Run();
+    }
     if (worker->spawn_) {
-      Thread::Current()->SetState(kNative);
       runtime->DetachCurrentThread();
     }
     return NULL;
@@ -1296,12 +1338,12 @@
     // Destroy the old context
     delete context_;
 
-    // TODO: Add a callback to let the client specify the class_linker and
-    //       dex_cache in the context for the current working dex file.
+    // TODO: Add a callback to let the client specify the class_linker in the context for the
+    //       current working dex file.
     context_ = new CompilationContext(/* class_linker */NULL,
                                       worker_context_->GetClassLoader(),
                                       worker_context_->GetCompiler(),
-                                      /* dex_cache */NULL, dex_file);
+                                      dex_file);
 
     CHECK(context_ != NULL);
   }
@@ -1314,8 +1356,7 @@
     SwitchToDexFile(0);
 
     while (true) {
-      size_t class_index =
-          static_cast<size_t>(android_atomic_inc(shared_class_index_));
+      size_t class_index = static_cast<size_t>(android_atomic_inc(shared_class_index_));
 
       const DexFile* dex_file;
       do {
@@ -1339,7 +1380,7 @@
 
       class_index -= class_index_base;
       class_callback_(context_, class_index);
-      CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+      self->AssertNoPendingException();
     }
   }
 
@@ -1362,7 +1403,7 @@
                              const std::vector<const DexFile*>& dex_files,
                              Callback class_callback, size_t thread_count) {
   Thread* self = Thread::Current();
-  CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+  self->AssertNoPendingException();
   CHECK_GT(thread_count, 0U);
 
   std::vector<DexFilesWorkerThread*> threads;
@@ -1375,13 +1416,16 @@
   }
   threads[0]->Go();
 
-  // Switch to kVmWait while we're blocked waiting for the other threads to finish.
-  ScopedThreadStateChange tsc(self, kVmWait);
+  // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
+  // thread destructor's called below perform join).
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_NE(self->GetState(), kRunnable);
+  }
   STLDeleteElements(&threads);
 }
 
-void Compiler::Compile(ClassLoader* class_loader,
-                       const std::vector<const DexFile*>& dex_files) {
+void Compiler::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
 #if defined(ART_USE_LLVM_COMPILER)
   if (dex_files.size() <= 0) {
     return;  // No dex file
@@ -1397,12 +1441,16 @@
 #endif
 }
 
-void Compiler::CompileClass(CompilationContext* context, size_t class_def_index) {
-  ClassLoader* class_loader = context->GetClassLoader();
+void Compiler::CompileClass(const CompilationContext* context, size_t class_def_index) {
+  jobject class_loader = context->GetClassLoader();
   const DexFile& dex_file = *context->GetDexFile();
   const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
-  if (SkipClass(class_loader, dex_file, class_def)) {
-    return;
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
+    if (SkipClass(class_loader, dex_file, class_def)) {
+      return;
+    }
   }
   ClassReference ref(&dex_file, class_def_index);
   // Skip compiling classes with generic verifier failures since they will still fail at runtime
@@ -1455,8 +1503,8 @@
   DCHECK(!it.HasNext());
 }
 
-void Compiler::CompileDexFile(ClassLoader* class_loader, const DexFile& dex_file) {
-  CompilationContext context(NULL, class_loader, this, NULL, &dex_file);
+void Compiler::CompileDexFile(jobject class_loader, const DexFile& dex_file) {
+  CompilationContext context(NULL, class_loader, this, &dex_file);
   ForAll(&context, 0, dex_file.NumClassDefs(), Compiler::CompileClass, thread_count_);
 }
 
@@ -1469,7 +1517,7 @@
 }
 
 void Compiler::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
-                             uint32_t method_idx, ClassLoader* class_loader,
+                             uint32_t method_idx, jobject class_loader,
                              const DexFile& dex_file) {
   CompiledMethod* compiled_method = NULL;
   uint64_t start_ns = NanoTime();
@@ -1492,8 +1540,10 @@
   if (compiled_method != NULL) {
     MethodReference ref(&dex_file, method_idx);
     CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
-    MutexLock mu(compiled_methods_lock_);
-    compiled_methods_.Put(ref, compiled_method);
+    {
+      MutexLock mu(compiled_methods_lock_);
+      compiled_methods_.Put(ref, compiled_method);
+    }
     DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
   }
 
@@ -1519,7 +1569,11 @@
   }
 #endif
 
-  CHECK(!Thread::Current()->IsExceptionPending()) << PrettyMethod(method_idx, dex_file);
+  if (Thread::Current()->IsExceptionPending()) {
+    ScopedObjectAccess soa(Thread::Current());
+    LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
+        << Thread::Current()->GetException()->Dump();
+  }
 }
 
 const CompiledInvokeStub* Compiler::FindInvokeStub(bool is_static, const char* shorty) const {
@@ -1595,7 +1649,7 @@
   return it->second;
 }
 
-void Compiler::SetGcMaps(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files) {
+void Compiler::SetGcMaps(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
   for (size_t i = 0; i != dex_files.size(); ++i) {
     const DexFile* dex_file = dex_files[i];
     CHECK(dex_file != NULL);
@@ -1603,7 +1657,9 @@
   }
 }
 
-void Compiler::SetGcMapsDexFile(ClassLoader* class_loader, const DexFile& dex_file) {
+void Compiler::SetGcMapsDexFile(jobject jni_class_loader, const DexFile& dex_file) {
+  ScopedObjectAccess soa(Thread::Current());
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(jni_class_loader);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   DexCache* dex_cache = class_linker->FindDexCache(dex_file);
   for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
diff --git a/src/compiler.h b/src/compiler.h
index 85f3ead..01ef037 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -52,11 +52,12 @@
 
   ~Compiler();
 
-  void CompileAll(ClassLoader* class_loader,
-                  const std::vector<const DexFile*>& dex_files);
+  void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Compile a single Method
-  void CompileOne(const Method* method);
+  void CompileOne(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsDebuggingSupported() {
     return support_debugging_;
@@ -71,75 +72,89 @@
   }
 
   // Stub to throw AbstractMethodError
-  static ByteArray* CreateAbstractMethodErrorStub(InstructionSet instruction_set);
+  static ByteArray* CreateAbstractMethodErrorStub(InstructionSet instruction_set)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
   // Generate the trampoline that's invoked by unresolved direct methods
   static ByteArray* CreateResolutionStub(InstructionSet instruction_set,
-                                         Runtime::TrampolineType type);
+                                         Runtime::TrampolineType type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static ByteArray* CreateJniDlsymLookupStub(InstructionSet instruction_set);
+  static ByteArray* CreateJniDlsymLookupStub(InstructionSet instruction_set)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // A class is uniquely located by its DexFile and the class_defs_ table index into that DexFile
   typedef std::pair<const DexFile*, uint32_t> ClassReference;
 
-  CompiledClass* GetCompiledClass(ClassReference ref) const;
+  CompiledClass* GetCompiledClass(ClassReference ref) const
+      LOCKS_EXCLUDED(compiled_classes_lock_);
 
   // A method is uniquely located by its DexFile and the method_ids_ table index into that DexFile
   typedef std::pair<const DexFile*, uint32_t> MethodReference;
 
-  CompiledMethod* GetCompiledMethod(MethodReference ref) const;
+  CompiledMethod* GetCompiledMethod(MethodReference ref) const
+      LOCKS_EXCLUDED(compiled_methods_lock_);
 
   const CompiledInvokeStub* FindInvokeStub(bool is_static, const char* shorty) const;
-  const CompiledInvokeStub* FindInvokeStub(const std::string& key) const;
+  const CompiledInvokeStub* FindInvokeStub(const std::string& key) const
+      LOCKS_EXCLUDED(compiled_invoke_stubs_lock_);
 
 #if defined(ART_USE_LLVM_COMPILER)
   const CompiledInvokeStub* FindProxyStub(const char* shorty) const;
 #endif
 
-  // Callbacks from OAT/ART compiler to see what runtime checks must be generated
+  // Callbacks from compiler to see what runtime checks must be generated.
 
-  bool CanAssumeTypeIsPresentInDexCache(const DexCache* dex_cache, uint32_t type_idx);
+  bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  bool CanAssumeStringIsPresentInDexCache(const DexCache* dex_cache, uint32_t string_idx);
+  bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Are runtime access checks necessary in the compiled code?
-  bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexCache* dex_cache,
-                                  const DexFile& dex_file, uint32_t type_idx);
+  bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
+                                  uint32_t type_idx)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Are runtime access and instantiable checks necessary in the code?
-  bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexCache* dex_cache,
-                                              const DexFile& dex_file, uint32_t type_idx);
+  bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
+                                              uint32_t type_idx)
+     LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  // Can we fast path instance field access? Computes field's offset and volatility
+  // Can we fast path instance field access? Computes field's offset and volatility.
   bool ComputeInstanceFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
-                                int& field_offset, bool& is_volatile, bool is_put);
+                                int& field_offset, bool& is_volatile, bool is_put)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Can we fastpath static field access? Computes field's offset, volatility and whether the
-  // field is within the referrer (which can avoid checking class initialization)
+  // field is within the referrer (which can avoid checking class initialization).
   bool ComputeStaticFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
                               int& field_offset, int& ssb_index,
-                              bool& is_referrers_class, bool& is_volatile, bool is_put);
+                              bool& is_referrers_class, bool& is_volatile, bool is_put)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  // Can we fastpath a interface, super class or virtual method call? Computes method's vtable index
+  // Can we fastpath a interface, super class or virtual method call? Computes method's vtable
+  // index.
   bool ComputeInvokeInfo(uint32_t method_idx, OatCompilationUnit* mUnit, InvokeType& type,
-                         int& vtable_idx, uintptr_t& direct_code, uintptr_t& direct_method);
+                         int& vtable_idx, uintptr_t& direct_code, uintptr_t& direct_method)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  // Record patch information for later fix up
-  void AddCodePatch(DexCache* dex_cache,
-                    const DexFile* dex_file,
+  // Record patch information for later fix up.
+  void AddCodePatch(const DexFile* dex_file,
                     uint32_t referrer_method_idx,
                     uint32_t referrer_access_flags,
                     uint32_t target_method_idx,
                     bool target_is_direct,
-                    size_t literal_offset);
-  void AddMethodPatch(DexCache* dex_cache,
-                      const DexFile* dex_file,
+                    size_t literal_offset)
+      LOCKS_EXCLUDED(compiled_methods_lock_);
+  void AddMethodPatch(const DexFile* dex_file,
                       uint32_t referrer_method_idx,
                       uint32_t referrer_access_flags,
                       uint32_t target_method_idx,
                       bool target_is_direct,
-                      size_t literal_offset);
+                      size_t literal_offset)
+      LOCKS_EXCLUDED(compiled_methods_lock_);
 
 #if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_QUICK_COMPILER)
   void SetBitcodeFileName(std::string const& filename);
@@ -159,9 +174,6 @@
 
   class PatchInformation {
    public:
-    DexCache* GetDexCache() const {
-      return dex_cache_;
-    }
     const DexFile& GetDexFile() const {
       return *dex_file_;
     }
@@ -182,15 +194,13 @@
     }
 
    private:
-    PatchInformation(DexCache* dex_cache,
-                     const DexFile* dex_file,
+    PatchInformation(const DexFile* dex_file,
                      uint32_t referrer_method_idx,
                      uint32_t referrer_access_flags,
                      uint32_t target_method_idx,
                      uint32_t target_is_direct,
                      size_t literal_offset)
-      : dex_cache_(dex_cache),
-        dex_file_(dex_file),
+      : dex_file_(dex_file),
         referrer_method_idx_(referrer_method_idx),
         referrer_is_direct_(Method::IsDirect(referrer_access_flags)),
         target_method_idx_(target_method_idx),
@@ -199,7 +209,6 @@
       CHECK(dex_file_ != NULL);
     }
 
-    DexCache* dex_cache_;
     const DexFile* dex_file_;
     uint32_t referrer_method_idx_;
     bool referrer_is_direct_;
@@ -221,39 +230,55 @@
  private:
   // Compute constant code and method pointers when possible
   void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, Method* method,
-                                     uintptr_t& direct_code, uintptr_t& direct_method);
+                                     uintptr_t& direct_code, uintptr_t& direct_method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Checks if class specified by type_idx is one of the image_classes_
   bool IsImageClass(const std::string& descriptor) const;
 
-  void PreCompile(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files, TimingLogger& timings);
-  void PostCompile(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
+  void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+                  TimingLogger& timings)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void PostCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files);
 
   // Attempt to resolve all type, methods, fields, and strings
   // referenced from code in the dex file following PathClassLoader
   // ordering semantics.
-  void Resolve(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files, TimingLogger& timings);
-  void ResolveDexFile(ClassLoader* class_loader, const DexFile& dex_file, TimingLogger& timings);
+  void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
+               TimingLogger& timings)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void ResolveDexFile(jobject class_loader, const DexFile& dex_file, TimingLogger& timings)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  void Verify(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
-  void VerifyDexFile(ClassLoader* class_loader, const DexFile& dex_file);
+  void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files);
+  void VerifyDexFile(jobject class_loader, const DexFile& dex_file)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  void InitializeClassesWithoutClinit(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
-  void InitializeClassesWithoutClinit(ClassLoader* class_loader, const DexFile& dex_file);
+  void InitializeClassesWithoutClinit(jobject class_loader,
+                                      const std::vector<const DexFile*>& dex_files)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void InitializeClassesWithoutClinit(jobject class_loader, const DexFile& dex_file)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_, compiled_classes_lock_);
 
-  void Compile(ClassLoader* class_loader,
-               const std::vector<const DexFile*>& dex_files);
-  void CompileDexFile(ClassLoader* class_loader, const DexFile& dex_file);
+  void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files);
+  void CompileDexFile(jobject class_loader, const DexFile& dex_file)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
   void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, uint32_t method_idx,
-                     ClassLoader* class_loader, const DexFile& dex_file);
+                     jobject class_loader, const DexFile& dex_file)
+      LOCKS_EXCLUDED(compiled_methods_lock_);
 
-  static void CompileClass(CompilationContext* context, size_t class_def_index);
+  static void CompileClass(const CompilationContext* context, size_t class_def_index)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  void SetGcMaps(ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
-  void SetGcMapsDexFile(ClassLoader* class_loader, const DexFile& dex_file);
-  void SetGcMapsMethod(const DexFile& dex_file, Method* method);
+  void SetGcMaps(jobject class_loader, const std::vector<const DexFile*>& dex_files)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void SetGcMapsDexFile(jobject class_loader, const DexFile& dex_file)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void SetGcMapsMethod(const DexFile& dex_file, Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void InsertInvokeStub(const std::string& key, const CompiledInvokeStub* compiled_invoke_stub);
+  void InsertInvokeStub(const std::string& key, const CompiledInvokeStub* compiled_invoke_stub)
+      LOCKS_EXCLUDED(compiled_invoke_stubs_lock_);
 
 #if defined(ART_USE_LLVM_COMPILER)
   void InsertProxyStub(const char* shorty, const CompiledInvokeStub* compiled_proxy_stub);
@@ -266,17 +291,17 @@
 
   typedef SafeMap<const ClassReference, CompiledClass*> ClassTable;
   // All class references that this compiler has compiled
-  mutable Mutex compiled_classes_lock_;
+  mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_);
 
   typedef SafeMap<const MethodReference, CompiledMethod*> MethodTable;
   // All method references that this compiler has compiled
-  mutable Mutex compiled_methods_lock_;
+  mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_);
 
   typedef SafeMap<std::string, const CompiledInvokeStub*> InvokeStubTable;
   // Invocation stubs created to allow invocation of the compiled methods
-  mutable Mutex compiled_invoke_stubs_lock_;
+  mutable Mutex compiled_invoke_stubs_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   InvokeStubTable compiled_invoke_stubs_ GUARDED_BY(compiled_invoke_stubs_lock_);
 
 #if defined(ART_USE_LLVM_COMPILER)
@@ -308,7 +333,7 @@
   typedef CompiledMethod* (*CompilerFn)(Compiler& compiler,
                                         const DexFile::CodeItem* code_item,
                                         uint32_t access_flags, uint32_t method_idx,
-                                        ClassLoader* class_loader,
+                                        jobject class_loader,
                                         const DexFile& dex_file);
   CompilerFn compiler_;
 
diff --git a/src/compiler/Compiler.h b/src/compiler/Compiler.h
index 088768b..00ab796 100644
--- a/src/compiler/Compiler.h
+++ b/src/compiler/Compiler.h
@@ -204,7 +204,7 @@
 extern "C" art::CompiledMethod* ArtCompileMethod(art::Compiler& compiler,
                                                  const art::DexFile::CodeItem* code_item,
                                                  uint32_t access_flags, uint32_t method_idx,
-                                                 const art::ClassLoader* class_loader,
+                                                 jobject class_loader,
                                                  const art::DexFile& dex_file);
 
 #endif // ART_SRC_COMPILER_COMPILER_H_
diff --git a/src/compiler/CompilerIR.h b/src/compiler/CompilerIR.h
index 1ecf61a..453ccdf 100644
--- a/src/compiler/CompilerIR.h
+++ b/src/compiler/CompilerIR.h
@@ -326,7 +326,6 @@
       compiler(NULL),
       class_linker(NULL),
       dex_file(NULL),
-      dex_cache(NULL),
       class_loader(NULL),
       method_idx(0),
       code_item(NULL),
@@ -436,8 +435,7 @@
   Compiler* compiler;            // Compiler driving this compiler
   ClassLinker* class_linker;     // Linker to resolve fields and methods
   const DexFile* dex_file;       // DexFile containing the method being compiled
-  DexCache* dex_cache;           // DexFile's corresponding cache
-  ClassLoader* class_loader;     // compiling method's class loader
+  jobject class_loader;          // compiling method's class loader
   uint32_t method_idx;                // compiling method's index into method_ids of DexFile
   const DexFile::CodeItem* code_item;  // compiling method's DexFile code_item
   uint32_t access_flags;              // compiling method's access flags
diff --git a/src/compiler/Dataflow.cc b/src/compiler/Dataflow.cc
index 33ef0ad..fc1d262 100644
--- a/src/compiler/Dataflow.cc
+++ b/src/compiler/Dataflow.cc
@@ -2274,7 +2274,7 @@
       return false;
   }
   OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                           *cUnit->dex_file, *cUnit->dex_cache,
+                           *cUnit->dex_file,
                            cUnit->code_item, cUnit->method_idx,
                            cUnit->access_flags);
   // TODO: add a flag so we don't counts the stats for this twice
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index 7585b77..6cdfebc 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -733,7 +733,7 @@
 CompiledMethod* oatCompileMethod(Compiler& compiler,
                                  const DexFile::CodeItem* code_item,
                                  uint32_t access_flags, uint32_t method_idx,
-                                 const ClassLoader* class_loader,
+                                 jobject class_loader,
                                  const DexFile& dex_file)
 {
   VLOG(compiler) << "Compiling " << PrettyMethod(method_idx, dex_file) << "...";
@@ -751,7 +751,6 @@
   cUnit->compiler = &compiler;
   cUnit->class_linker = class_linker;
   cUnit->dex_file = &dex_file;
-  cUnit->dex_cache = class_linker->FindDexCache(dex_file);
   cUnit->method_idx = method_idx;
   cUnit->code_item = code_item;
   cUnit->access_flags = access_flags;
@@ -1161,7 +1160,7 @@
     ArtCompileMethod(art::Compiler& compiler,
                      const art::DexFile::CodeItem* code_item,
                      uint32_t access_flags, uint32_t method_idx,
-                     const art::ClassLoader* class_loader,
+                     jobject class_loader,
                      const art::DexFile& dex_file)
 {
   CHECK_EQ(compiler.GetInstructionSet(), art::oatInstructionSet());
diff --git a/src/compiler/codegen/CodegenUtil.cc b/src/compiler/codegen/CodegenUtil.cc
index a33a162..dd7daba 100644
--- a/src/compiler/codegen/CodegenUtil.cc
+++ b/src/compiler/codegen/CodegenUtil.cc
@@ -644,7 +644,7 @@
   if (dataLIR != NULL) {
     while (dataLIR != NULL) {
       uint32_t target = dataLIR->operands[0];
-      cUnit->compiler->AddCodePatch(cUnit->dex_cache, cUnit->dex_file,
+      cUnit->compiler->AddCodePatch(cUnit->dex_file,
                                     cUnit->method_idx,
                                     cUnit->access_flags,
                                     target,
@@ -659,7 +659,7 @@
     dataLIR = cUnit->methodLiteralList;
     while (dataLIR != NULL) {
       uint32_t target = dataLIR->operands[0];
-      cUnit->compiler->AddMethodPatch(cUnit->dex_cache, cUnit->dex_file,
+      cUnit->compiler->AddMethodPatch(cUnit->dex_file,
                                       cUnit->method_idx,
                                       cUnit->access_flags,
                                       target,
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index baa4b48..6cb701f 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -502,7 +502,6 @@
   oatFlushAllRegs(cUnit);  /* Everything to home location */
   int funcOffset;
   if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                  cUnit->dex_cache,
                                                   *cUnit->dex_file,
                                                   type_idx)) {
     funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
@@ -527,7 +526,6 @@
   oatFlushAllRegs(cUnit);  /* Everything to home location */
   int funcOffset;
   if (cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                  cUnit->dex_cache,
                                                   *cUnit->dex_file,
                                                   typeIdx)) {
     funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
@@ -637,10 +635,8 @@
   bool isVolatile;
   bool isReferrersClass;
 
-  OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                           *cUnit->dex_file, *cUnit->dex_cache,
-                           cUnit->code_item, cUnit->method_idx,
-                           cUnit->access_flags);
+  OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker, *cUnit->dex_file,
+                           cUnit->code_item, cUnit->method_idx, cUnit->access_flags);
 
   bool fastPath =
       cUnit->compiler->ComputeStaticFieldInfo(fieldIdx, &mUnit,
@@ -735,7 +731,7 @@
   bool isReferrersClass;
 
   OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                           *cUnit->dex_file, *cUnit->dex_cache,
+                           *cUnit->dex_file,
                            cUnit->code_item, cUnit->method_idx,
                            cUnit->access_flags);
 
@@ -978,7 +974,7 @@
                   int& fieldOffset, bool& isVolatile, bool isPut)
 {
   OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-               *cUnit->dex_file, *cUnit->dex_cache,
+               *cUnit->dex_file,
                cUnit->code_item, cUnit->method_idx,
                cUnit->access_flags);
   return cUnit->compiler->ComputeInstanceFieldInfo(fieldIdx, &mUnit,
@@ -1102,7 +1098,6 @@
   int resReg = oatAllocTemp(cUnit);
   RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
   if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                   cUnit->dex_cache,
                                                    *cUnit->dex_file,
                                                    type_idx)) {
     // Call out to helper which resolves type and verifies access.
@@ -1121,7 +1116,7 @@
         Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
                           * type_idx);
     loadWordDisp(cUnit, resReg, offset_of_type, rlResult.lowReg);
-    if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(cUnit->dex_cache,
+    if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(*cUnit->dex_file,
         type_idx) || SLOW_TYPE_PATH) {
       // Slow path, at runtime test if type is null and if so initialize
       oatFlushAllRegs(cUnit);
@@ -1164,7 +1159,7 @@
   int32_t offset_of_string = Array::DataOffset(sizeof(String*)).Int32Value() +
                  (sizeof(String*) * string_idx);
   if (!cUnit->compiler->CanAssumeStringIsPresentInDexCache(
-      cUnit->dex_cache, string_idx) || SLOW_STRING_PATH) {
+      *cUnit->dex_file, string_idx) || SLOW_STRING_PATH) {
     // slow path, resolve string if not in dex cache
     oatFlushAllRegs(cUnit);
     oatLockCallTemps(cUnit); // Using explicit registers
@@ -1222,7 +1217,7 @@
   // access because the verifier was unable to?
   int funcOffset;
   if (cUnit->compiler->CanAccessInstantiableTypeWithoutChecks(
-      cUnit->method_idx, cUnit->dex_cache, *cUnit->dex_file, type_idx)) {
+      cUnit->method_idx, *cUnit->dex_file, type_idx)) {
     funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCode);
   } else {
     funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
@@ -1248,7 +1243,6 @@
   loadCurrMethodDirect(cUnit, rARG1);  // rARG1 <= current Method*
   int classReg = rARG2;  // rARG2 will hold the Class*
   if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                   cUnit->dex_cache,
                                                    *cUnit->dex_file,
                                                    type_idx)) {
     // Check we have access to type_idx and if not throw IllegalAccessError,
@@ -1268,7 +1262,7 @@
         * type_idx);
     loadWordDisp(cUnit, classReg, offset_of_type, classReg);
     if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
-        cUnit->dex_cache, type_idx)) {
+        *cUnit->dex_file, type_idx)) {
       // Need to test presence of type in dex cache at runtime
       LIR* hopBranch = opCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
       // Not resolved
@@ -1333,7 +1327,6 @@
   loadCurrMethodDirect(cUnit, rARG1);  // rARG1 <= current Method*
   int classReg = rARG2;  // rARG2 will hold the Class*
   if (!cUnit->compiler->CanAccessTypeWithoutChecks(cUnit->method_idx,
-                                                   cUnit->dex_cache,
                                                    *cUnit->dex_file,
                                                    type_idx)) {
     // Check we have access to type_idx and if not throw IllegalAccessError,
@@ -1352,7 +1345,7 @@
         (sizeof(Class*) * type_idx);
     loadWordDisp(cUnit, classReg, offset_of_type, classReg);
     if (!cUnit->compiler->CanAssumeTypeIsPresentInDexCache(
-        cUnit->dex_cache, type_idx)) {
+        *cUnit->dex_file, type_idx)) {
       // Need to test presence of type in dex cache at runtime
       LIR* hopBranch = opCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
       // Not resolved
diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index b93cbd9..e2a5f97 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -68,7 +68,7 @@
   oatLockCallTemps(cUnit);
 
   OatCompilationUnit mUnit(cUnit->class_loader, cUnit->class_linker,
-                           *cUnit->dex_file, *cUnit->dex_cache,
+                           *cUnit->dex_file,
                            cUnit->code_item, cUnit->method_idx,
                            cUnit->access_flags);
 
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index a42696c..2eb9c65 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -28,7 +28,7 @@
 #include "reflection.h"
 #include "runtime_support.h"
 #include "runtime_support_func_list.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "thread_list.h"
 #include "utils_llvm.h"
@@ -656,7 +656,7 @@
 
   // Start new JNI local reference state
   JNIEnvExt* env = thread->GetJniEnv();
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   ScopedJniEnvLocalRefState env_state(env);
 
   // Create local ref. copies of the receiver
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index 088726f..0c53bb9 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -31,14 +31,16 @@
 
 class CompilerTest : public CommonTest {
  protected:
-  void CompileAll(ClassLoader* class_loader) {
+  void CompileAll(jobject class_loader) LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     compiler_->CompileAll(class_loader, Runtime::Current()->GetCompileTimeClassPath(class_loader));
     MakeAllExecutable(class_loader);
   }
 
-  void EnsureCompiled(ClassLoader* class_loader, const char* class_name, const char* method,
-                      const char* signature, bool is_virtual) {
+  void EnsureCompiled(jobject class_loader, const char* class_name, const char* method,
+                      const char* signature, bool is_virtual)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     CompileAll(class_loader);
+    Thread::Current()->TransitionFromSuspendedToRunnable();
     runtime_->Start();
     env_ = Thread::Current()->GetJniEnv();
     class_ = env_->FindClass(class_name);
@@ -51,7 +53,7 @@
     CHECK(mid_ != NULL) << "Method not found: " << class_name << "." << method << signature;
   }
 
-  void MakeAllExecutable(ClassLoader* class_loader) {
+  void MakeAllExecutable(jobject class_loader) {
     const std::vector<const DexFile*>& class_path
         = Runtime::Current()->GetCompileTimeClassPath(class_loader);
     for (size_t i = 0; i != class_path.size(); ++i) {
@@ -61,12 +63,13 @@
     }
   }
 
-  void MakeDexFileExecutable(ClassLoader* class_loader, const DexFile& dex_file) {
+  void MakeDexFileExecutable(jobject class_loader, const DexFile& dex_file) {
     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
     for (size_t i = 0; i < dex_file.NumClassDefs(); i++) {
       const DexFile::ClassDef& class_def = dex_file.GetClassDef(i);
       const char* descriptor = dex_file.GetClassDescriptor(class_def);
-      Class* c = class_linker->FindClass(descriptor, class_loader);
+      ScopedObjectAccess soa(Thread::Current());
+      Class* c = class_linker->FindClass(descriptor, soa.Decode<ClassLoader*>(class_loader));
       CHECK(c != NULL);
       for (size_t i = 0; i < c->NumDirectMethods(); i++) {
         MakeExecutable(c->GetDirectMethod(i));
@@ -87,6 +90,7 @@
   CompileAll(NULL);
 
   // All libcore references should resolve
+  ScopedObjectAccess soa(Thread::Current());
   const DexFile* dex = java_lang_dex_file_;
   DexCache* dex_cache = class_linker_->FindDexCache(*dex);
   EXPECT_EQ(dex->NumStringIds(), dex_cache->NumStrings());
@@ -125,12 +129,15 @@
 }
 
 TEST_F(CompilerTest, AbstractMethodErrorStub) {
-  CompileVirtualMethod(NULL, "java.lang.Class", "isFinalizable", "()Z");
-  CompileDirectMethod(NULL, "java.lang.Object", "<init>", "()V");
-
-  SirtRef<ClassLoader> class_loader(LoadDex("AbstractMethod"));
-  ASSERT_TRUE(class_loader.get() != NULL);
-  EnsureCompiled(class_loader.get(), "AbstractClass", "foo", "()V", true);
+  jobject class_loader;
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    CompileVirtualMethod(NULL, "java.lang.Class", "isFinalizable", "()Z");
+    CompileDirectMethod(NULL, "java.lang.Object", "<init>", "()V");
+    class_loader = LoadDex("AbstractMethod");
+  }
+  ASSERT_TRUE(class_loader != NULL);
+  EnsureCompiled(class_loader, "AbstractClass", "foo", "()V", true);
 
   // Create a jobj_ of ConcreteClass, NOT AbstractClass.
   jclass c_class = env_->FindClass("ConcreteClass");
@@ -138,11 +145,13 @@
   jobject jobj_ = env_->NewObject(c_class, constructor);
   ASSERT_TRUE(jobj_ != NULL);
 
-  Class* jlame = class_linker_->FindClass("Ljava/lang/AbstractMethodError;", class_loader.get());
   // Force non-virtual call to AbstractClass foo, will throw AbstractMethodError exception.
   env_->CallNonvirtualVoidMethod(jobj_, class_, mid_);
-  EXPECT_TRUE(Thread::Current()->IsExceptionPending());
-  EXPECT_TRUE(Thread::Current()->GetException()->InstanceOf(jlame));
+  EXPECT_EQ(env_->ExceptionCheck(), JNI_TRUE);
+  jthrowable exception = env_->ExceptionOccurred();
+  env_->ExceptionClear();
+  jclass jlame = env_->FindClass("java/lang/AbstractMethodError");
+  EXPECT_TRUE(env_->IsInstanceOf(exception, jlame));
   Thread::Current()->ClearException();
 }
 
diff --git a/src/debugger.cc b/src/debugger.cc
index cd52f82..edb6e7f 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -28,10 +28,9 @@
 #endif
 #include "object_utils.h"
 #include "safe_map.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
 #include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "stack_indirect_reference_table.h"
 #include "thread_list.h"
@@ -91,7 +90,7 @@
   }
 
  private:
-  Mutex lock_;
+  Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   SafeMap<JDWP::ObjectId, Object*> map_;
 };
 
@@ -99,7 +98,7 @@
   Method* method;
   uint32_t dex_pc;
 
-  int32_t LineNumber() const {
+  int32_t LineNumber() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return MethodHelper(method).GetLineNumFromDexPC(dex_pc);
   }
 };
@@ -125,7 +124,8 @@
   Breakpoint(Method* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
 };
 
-static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs) {
+static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   os << StringPrintf("Breakpoint[%s @%#x]", PrettyMethod(rhs.method).c_str(), rhs.dex_pc);
   return os;
 }
@@ -171,17 +171,18 @@
 static ObjectRegistry* gRegistry = NULL;
 
 // Recent allocation tracking.
-static Mutex gAllocTrackerLock("AllocTracker lock");
+static Mutex gAllocTrackerLock DEFAULT_MUTEX_ACQUIRED_AFTER ("AllocTracker lock");
 AllocRecord* Dbg::recent_allocation_records_ PT_GUARDED_BY(gAllocTrackerLock) = NULL; // TODO: CircularBuffer<AllocRecord>
 static size_t gAllocRecordHead GUARDED_BY(gAllocTrackerLock) = 0;
 static size_t gAllocRecordCount GUARDED_BY(gAllocTrackerLock) = 0;
 
 // Breakpoints and single-stepping.
-static Mutex gBreakpointsLock("breakpoints lock");
+static Mutex gBreakpointsLock DEFAULT_MUTEX_ACQUIRED_AFTER ("breakpoints lock");
 static std::vector<Breakpoint> gBreakpoints GUARDED_BY(gBreakpointsLock);
 static SingleStepControl gSingleStepControl GUARDED_BY(gBreakpointsLock);
 
-static bool IsBreakpoint(Method* m, uint32_t dex_pc) {
+static bool IsBreakpoint(Method* m, uint32_t dex_pc)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   MutexLock mu(gBreakpointsLock);
   for (size_t i = 0; i < gBreakpoints.size(); ++i) {
     if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == dex_pc) {
@@ -192,7 +193,8 @@
   return false;
 }
 
-static Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status) {
+static Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Object* o = gRegistry->Get<Object*>(id);
   if (o == NULL || o == kInvalidObject) {
     status = JDWP::ERR_INVALID_OBJECT;
@@ -206,7 +208,8 @@
   return o->AsArray();
 }
 
-static Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status) {
+static Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Object* o = gRegistry->Get<Object*>(id);
   if (o == NULL || o == kInvalidObject) {
     status = JDWP::ERR_INVALID_OBJECT;
@@ -220,13 +223,15 @@
   return o->AsClass();
 }
 
-static Thread* DecodeThread(JDWP::ObjectId threadId) {
-  ScopedJniThreadState ts(Thread::Current());
+static Thread* DecodeThread(ScopedObjectAccessUnchecked& soa, JDWP::ObjectId threadId)
+    LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Object* thread_peer = gRegistry->Get<Object*>(threadId);
   if (thread_peer == NULL || thread_peer == kInvalidObject) {
     return NULL;
   }
-  return Thread::FromManagedThread(ts, thread_peer);
+  Thread* thread = Thread::FromManagedThread(soa, thread_peer);
+  return thread;
 }
 
 static JDWP::JdwpTag BasicTagFromDescriptor(const char* descriptor) {
@@ -235,7 +240,8 @@
   return static_cast<JDWP::JdwpTag>(descriptor[0]);
 }
 
-static JDWP::JdwpTag TagFromClass(Class* c) {
+static JDWP::JdwpTag TagFromClass(Class* c)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   CHECK(c != NULL);
   if (c->IsArrayClass()) {
     return JDWP::JT_ARRAY;
@@ -265,7 +271,8 @@
  *
  * Null objects are tagged JT_OBJECT.
  */
-static JDWP::JdwpTag TagFromObject(const Object* o) {
+static JDWP::JdwpTag TagFromObject(const Object* o)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return (o == NULL) ? JDWP::JT_OBJECT : TagFromClass(o->GetClass());
 }
 
@@ -417,7 +424,7 @@
   // If a debugger has already attached, send the "welcome" message.
   // This may cause us to suspend all threads.
   if (gJdwpState->IsActive()) {
-    //ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+    ScopedObjectAccess soa(Thread::Current());
     if (!gJdwpState->PostVMStart()) {
       LOG(WARNING) << "Failed to post 'start' message to debugger";
     }
@@ -432,14 +439,17 @@
 
 void Dbg::GcDidFinish() {
   if (gDdmHpifWhen != HPIF_WHEN_NEVER) {
+    ScopedObjectAccess soa(Thread::Current());
     LOG(DEBUG) << "Sending heap info to DDM";
     DdmSendHeapInfo(gDdmHpifWhen);
   }
   if (gDdmHpsgWhen != HPSG_WHEN_NEVER) {
+    ScopedObjectAccess soa(Thread::Current());
     LOG(DEBUG) << "Dumping heap to DDM";
     DdmSendHeapSegments(false);
   }
   if (gDdmNhsgWhen != HPSG_WHEN_NEVER) {
+    ScopedObjectAccess soa(Thread::Current());
     LOG(DEBUG) << "Dumping native heap to DDM";
     DdmSendHeapSegments(true);
   }
@@ -481,6 +491,7 @@
 }
 
 static void SetDebuggerUpdatesEnabled(bool enabled) {
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(SetDebuggerUpdatesEnabledCallback, &enabled);
 }
 
@@ -528,18 +539,6 @@
   return gJdwpState->LastDebuggerActivity();
 }
 
-int Dbg::ThreadRunning() {
-  return static_cast<int>(Thread::Current()->SetState(kRunnable));
-}
-
-int Dbg::ThreadWaiting() {
-  return static_cast<int>(Thread::Current()->SetState(kVmWait));
-}
-
-int Dbg::ThreadContinuing(int new_state) {
-  return static_cast<int>(Thread::Current()->SetState(static_cast<ThreadState>(new_state)));
-}
-
 void Dbg::UndoDebuggerSuspensions() {
   Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
 }
@@ -829,7 +828,9 @@
   return JDWP::ERR_NONE;
 }
 
-JDWP::JdwpError Dbg::SetArrayElements(JDWP::ObjectId arrayId, int offset, int count, const uint8_t* src) {
+JDWP::JdwpError Dbg::SetArrayElements(JDWP::ObjectId arrayId, int offset, int count,
+                                      const uint8_t* src)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   JDWP::JdwpError status;
   Array* a = DecodeArray(arrayId, status);
   if (a == NULL) {
@@ -898,7 +899,8 @@
 /*
  * Used by Eclipse's "Display" view to evaluate "new byte[5]" to get "(byte[]) [0, 0, 0, 0, 0]".
  */
-JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId arrayClassId, uint32_t length, JDWP::ObjectId& new_array) {
+JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId arrayClassId, uint32_t length,
+                                       JDWP::ObjectId& new_array) {
   JDWP::JdwpError status;
   Class* c = DecodeClass(arrayClassId, status);
   if (c == NULL) {
@@ -917,7 +919,8 @@
   return c1->IsAssignableFrom(c2);
 }
 
-static JDWP::FieldId ToFieldId(const Field* f) {
+static JDWP::FieldId ToFieldId(const Field* f)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
@@ -925,7 +928,8 @@
 #endif
 }
 
-static JDWP::MethodId ToMethodId(const Method* m) {
+static JDWP::MethodId ToMethodId(const Method* m)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
@@ -933,7 +937,8 @@
 #endif
 }
 
-static Field* FromFieldId(JDWP::FieldId fid) {
+static Field* FromFieldId(JDWP::FieldId fid)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
@@ -941,7 +946,8 @@
 #endif
 }
 
-static Method* FromMethodId(JDWP::MethodId mid) {
+static Method* FromMethodId(JDWP::MethodId mid)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
 #ifdef MOVING_GARBAGE_COLLECTOR
   UNIMPLEMENTED(FATAL);
 #else
@@ -949,7 +955,8 @@
 #endif
 }
 
-static void SetLocation(JDWP::JdwpLocation& location, Method* m, uint32_t dex_pc) {
+static void SetLocation(JDWP::JdwpLocation& location, Method* m, uint32_t dex_pc)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (m == NULL) {
     memset(&location, 0, sizeof(location));
   } else {
@@ -961,7 +968,8 @@
   }
 }
 
-std::string Dbg::GetMethodName(JDWP::RefTypeId, JDWP::MethodId methodId) {
+std::string Dbg::GetMethodName(JDWP::RefTypeId, JDWP::MethodId methodId)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Method* m = FromMethodId(methodId);
   return MethodHelper(m).GetName();
 }
@@ -1004,7 +1012,8 @@
   return newSlot;
 }
 
-static uint16_t DemangleSlot(uint16_t slot, Method* m) {
+static uint16_t DemangleSlot(uint16_t slot, Method* m)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (slot == kEclipseWorkaroundSlot) {
     return 0;
   } else if (slot == 0) {
@@ -1042,7 +1051,8 @@
   return JDWP::ERR_NONE;
 }
 
-JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId classId, bool with_generic, JDWP::ExpandBuf* pReply) {
+JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId classId, bool with_generic,
+                                           JDWP::ExpandBuf* pReply) {
   JDWP::JdwpError status;
   Class* c = DecodeClass(classId, status);
   if (c == NULL) {
@@ -1085,7 +1095,8 @@
   return JDWP::ERR_NONE;
 }
 
-void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId methodId, JDWP::ExpandBuf* pReply) {
+void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId methodId, JDWP::ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   struct DebugCallbackContext {
     int numItems;
     JDWP::ExpandBuf* pReply;
@@ -1098,7 +1109,6 @@
       return true;
     }
   };
-
   Method* m = FromMethodId(methodId);
   MethodHelper mh(m);
   uint64_t start, end;
@@ -1153,7 +1163,6 @@
       ++pContext->variable_count;
     }
   };
-
   Method* m = FromMethodId(methodId);
   MethodHelper mh(m);
   const DexFile::CodeItem* code_item = mh.GetCodeItem();
@@ -1186,7 +1195,10 @@
   return BasicTagFromDescriptor(FieldHelper(FromFieldId(fieldId)).GetTypeDescriptor());
 }
 
-static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId refTypeId, JDWP::ObjectId objectId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply, bool is_static) {
+static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId refTypeId, JDWP::ObjectId objectId,
+                                         JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply,
+                                         bool is_static)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   JDWP::JdwpError status;
   Class* c = DecodeClass(refTypeId, status);
   if (refTypeId != 0 && c == NULL) {
@@ -1245,7 +1257,8 @@
   return JDWP::ERR_NONE;
 }
 
-JDWP::JdwpError Dbg::GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply) {
+JDWP::JdwpError Dbg::GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
+                                   JDWP::ExpandBuf* pReply) {
   return GetFieldValueImpl(0, objectId, fieldId, pReply, false);
 }
 
@@ -1253,7 +1266,9 @@
   return GetFieldValueImpl(refTypeId, 0, fieldId, pReply, true);
 }
 
-static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId objectId, JDWP::FieldId fieldId, uint64_t value, int width, bool is_static) {
+static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
+                                         uint64_t value, int width, bool is_static)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Object* o = gRegistry->Get<Object*>(objectId);
   if ((!is_static && o == NULL) || o == kInvalidObject) {
     return JDWP::ERR_INVALID_OBJECT;
@@ -1300,7 +1315,8 @@
   return JDWP::ERR_NONE;
 }
 
-JDWP::JdwpError Dbg::SetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, uint64_t value, int width) {
+JDWP::JdwpError Dbg::SetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, uint64_t value,
+                                   int width) {
   return SetFieldValueImpl(objectId, fieldId, value, width, false);
 }
 
@@ -1314,8 +1330,9 @@
 }
 
 bool Dbg::GetThreadName(JDWP::ObjectId threadId, std::string& name) {
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = DecodeThread(threadId);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return false;
   }
@@ -1324,13 +1341,15 @@
 }
 
 JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
+  ScopedObjectAccess soa(Thread::Current());
   Object* thread = gRegistry->Get<Object*>(threadId);
   if (thread == kInvalidObject) {
     return JDWP::ERR_INVALID_OBJECT;
   }
 
   // Okay, so it's an object, but is it actually a thread?
-  if (DecodeThread(threadId) == NULL) {
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  if (DecodeThread(soa, threadId) == NULL) {
     return JDWP::ERR_INVALID_THREAD;
   }
 
@@ -1347,6 +1366,7 @@
 }
 
 std::string Dbg::GetThreadGroupName(JDWP::ObjectId threadGroupId) {
+  ScopedObjectAccess soa(Thread::Current());
   Object* thread_group = gRegistry->Get<Object*>(threadGroupId);
   CHECK(thread_group != NULL);
 
@@ -1371,27 +1391,30 @@
 }
 
 JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccessUnchecked soa(Thread::Current());
   Object* group =
-      ts.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup)->GetObject(NULL);
+      soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup)->GetObject(NULL);
   return gRegistry->Add(group);
 }
 
 JDWP::ObjectId Dbg::GetMainThreadGroupId() {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccess soa(Thread::Current());
   Object* group =
-      ts.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup)->GetObject(NULL);
+      soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup)->GetObject(NULL);
   return gRegistry->Add(group);
 }
 
 bool Dbg::GetThreadStatus(JDWP::ObjectId threadId, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus) {
-  ScopedThreadListLock thread_list_lock;
+  ScopedObjectAccess soa(Thread::Current());
 
-  Thread* thread = DecodeThread(threadId);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return false;
   }
 
+  MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+
   // TODO: if we're in Thread.sleep(long), we should return TS_SLEEPING,
   // even if it's implemented using Object.wait(long).
   switch (thread->GetState()) {
@@ -1402,7 +1425,16 @@
     case kWaiting:      *pThreadStatus = JDWP::TS_WAIT;     break;
     case kStarting:     *pThreadStatus = JDWP::TS_ZOMBIE;   break;
     case kNative:       *pThreadStatus = JDWP::TS_RUNNING;  break;
-    case kVmWait:       *pThreadStatus = JDWP::TS_WAIT;     break;
+    case kWaitingForGcToComplete:  // Fall-through.
+    case kWaitingPerformingGc:  // Fall-through.
+    case kWaitingForDebuggerSend:  // Fall-through.
+    case kWaitingForDebuggerToAttach:  // Fall-through.
+    case kWaitingInMainDebuggerLoop:  // Fall-through.
+    case kWaitingForDebuggerSuspension:  // Fall-through.
+    case kWaitingForJniOnLoad:  // Fall-through.
+    case kWaitingForSignalCatcherOutput:  // Fall-through.
+    case kWaitingInMainSignalCatcherLoop:
+                        *pThreadStatus = JDWP::TS_WAIT;     break;
     case kSuspended:    *pThreadStatus = JDWP::TS_RUNNING;  break;
     // Don't add a 'default' here so the compiler can spot incompatible enum changes.
   }
@@ -1412,34 +1444,49 @@
   return true;
 }
 
-JDWP::JdwpError Dbg::GetThreadSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
-  Thread* thread = DecodeThread(threadId);
+JDWP::JdwpError Dbg::GetThreadDebugSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
+  ScopedObjectAccess soa(Thread::Current());
+
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return JDWP::ERR_INVALID_THREAD;
   }
-  expandBufAdd4BE(pReply, thread->GetSuspendCount());
+  MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+  expandBufAdd4BE(pReply, thread->GetDebugSuspendCount());
   return JDWP::ERR_NONE;
 }
 
 bool Dbg::ThreadExists(JDWP::ObjectId threadId) {
-  return DecodeThread(threadId) != NULL;
+  ScopedObjectAccess soa(Thread::Current());
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  return DecodeThread(soa, threadId) != NULL;
 }
 
 bool Dbg::IsSuspended(JDWP::ObjectId threadId) {
-  return DecodeThread(threadId)->IsSuspended();
+  ScopedObjectAccess soa(Thread::Current());
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = DecodeThread(soa, threadId);
+  CHECK(thread != NULL);
+  MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+  return thread->IsSuspended();
 }
 
 void Dbg::GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids) {
   class ThreadListVisitor {
    public:
-    ThreadListVisitor(const ScopedJniThreadState& ts, Object* thread_group, std::vector<JDWP::ObjectId>& thread_ids)
+    ThreadListVisitor(const ScopedObjectAccessUnchecked& ts, Object* thread_group,
+                      std::vector<JDWP::ObjectId>& thread_ids)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : ts_(ts), thread_group_(thread_group), thread_ids_(thread_ids) {}
 
     static void Visit(Thread* t, void* arg) {
       reinterpret_cast<ThreadListVisitor*>(arg)->Visit(t);
     }
 
-    void Visit(Thread* t) {
+    // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+    // annotalysis.
+    void Visit(Thread* t) NO_THREAD_SAFETY_ANALYSIS {
       if (t == Dbg::GetDebugThread()) {
         // Skip the JDWP thread. Some debuggers get bent out of shape when they can't suspend and
         // query all threads, so it's easier if we just don't tell them about this thread.
@@ -1451,19 +1498,20 @@
     }
 
    private:
-    const ScopedJniThreadState& ts_;
+    const ScopedObjectAccessUnchecked& ts_;
     Object* const thread_group_;
     std::vector<JDWP::ObjectId>& thread_ids_;
   };
 
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccessUnchecked soa(Thread::Current());
   Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
-  ThreadListVisitor tlv(ts, thread_group, thread_ids);
+  ThreadListVisitor tlv(soa, thread_group, thread_ids);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(ThreadListVisitor::Visit, &tlv);
 }
 
 void Dbg::GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& child_thread_group_ids) {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccess soa(Thread::Current());
   Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
 
   // Get the ArrayList<ThreadGroup> "groups" out of this thread group...
@@ -1482,7 +1530,8 @@
   }
 }
 
-static int GetStackDepth(Thread* thread) {
+static int GetStackDepth(Thread* thread)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   struct CountStackDepthVisitor : public StackVisitor {
     CountStackDepthVisitor(const ManagedStack* stack,
                            const std::vector<TraceStackFrame>* trace_stack)
@@ -1497,28 +1546,34 @@
     size_t depth;
   };
 
+  if (kIsDebugBuild) {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK(thread->IsSuspended());
+  }
   CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
   visitor.WalkStack();
   return visitor.depth;
 }
 
 int Dbg::GetThreadFrameCount(JDWP::ObjectId threadId) {
-  ScopedThreadListLock thread_list_lock;
-  return GetStackDepth(DecodeThread(threadId));
+  ScopedObjectAccess soa(Thread::Current());
+  return GetStackDepth(DecodeThread(soa, threadId));
 }
 
 JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf) {
-  ScopedThreadListLock thread_list_lock;
   class GetFrameVisitor : public StackVisitor {
    public:
     GetFrameVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
                     size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : StackVisitor(stack, trace_stack, NULL), depth_(0),
           start_frame_(start_frame), frame_count_(frame_count), buf_(buf) {
       expandBufAdd4BE(buf_, frame_count_);
     }
 
-    bool VisitFrame() {
+    // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+    // annotalysis.
+    virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
       if (GetMethod()->IsRuntimeMethod()) {
         return true; // The debugger can't do anything useful with a frame that has no Method*.
       }
@@ -1543,7 +1598,9 @@
     const size_t frame_count_;
     JDWP::ExpandBuf* buf_;
   };
-  Thread* thread = DecodeThread(thread_id);
+
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread = DecodeThread(soa, thread_id);  // Caller already checked thread is suspended.
   GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), start_frame, frame_count, buf);
   visitor.WalkStack();
   return JDWP::ERR_NONE;
@@ -1554,36 +1611,51 @@
 }
 
 void Dbg::SuspendVM() {
-  ScopedThreadStateChange tsc(Thread::Current(), kRunnable); // TODO: do we really want to change back? should the JDWP thread be Runnable usually?
-  Runtime::Current()->GetThreadList()->SuspendAll(true);
+  Runtime::Current()->GetThreadList()->SuspendAllForDebugger();
 }
 
 void Dbg::ResumeVM() {
   Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
 }
 
-void Dbg::SuspendThread(JDWP::ObjectId threadId) {
-  ScopedJniThreadState ts(Thread::Current());
-  Object* peer = gRegistry->Get<Object*>(threadId);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, peer);
-  if (thread == NULL) {
-    LOG(WARNING) << "No such thread for suspend: " << peer;
-    return;
+JDWP::JdwpError Dbg::SuspendThread(JDWP::ObjectId threadId, bool request_suspension) {
+
+  bool timeout;
+  ScopedLocalRef<jobject> peer(Thread::Current()->GetJniEnv(), NULL);
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<Object*>(threadId)));
   }
-  Runtime::Current()->GetThreadList()->Suspend(thread, true);
+  if (peer.get() == NULL) {
+    LOG(WARNING) << "No such thread for suspend: " << threadId;
+    return JDWP::ERR_THREAD_NOT_ALIVE;
+  }
+  // Suspend thread to build stack trace.
+  Thread* thread = Thread::SuspendForDebugger(peer.get(), request_suspension, &timeout);
+  if (thread != NULL) {
+    return JDWP::ERR_NONE;
+  } else if (timeout) {
+    return JDWP::ERR_INTERNAL;
+  } else {
+    return JDWP::ERR_THREAD_NOT_ALIVE;
+  }
 }
 
 void Dbg::ResumeThread(JDWP::ObjectId threadId) {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccessUnchecked soa(Thread::Current());
   Object* peer = gRegistry->Get<Object*>(threadId);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, peer);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, peer);
   if (thread == NULL) {
     LOG(WARNING) << "No such thread for resume: " << peer;
     return;
   }
-  if (thread->GetSuspendCount() > 0) {
+  bool needs_resume;
+  {
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+    needs_resume = thread->GetSuspendCount() > 0;
+  }
+  if (needs_resume) {
     Runtime::Current()->GetThreadList()->Resume(thread, true);
   }
 }
@@ -1595,9 +1667,12 @@
 struct GetThisVisitor : public StackVisitor {
   GetThisVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
                  Context* context, JDWP::FrameId frameId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(stack, trace_stack, context), this_object(NULL), frame_id(frameId) {}
 
-  virtual bool VisitFrame() {
+  // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+  // annotalysis.
+  virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
     if (frame_id != GetFrameId()) {
       return true;  // continue
     }
@@ -1615,7 +1690,8 @@
   JDWP::FrameId frame_id;
 };
 
-static Object* GetThis(Thread* self, Method* m, size_t frame_id) {
+static Object* GetThis(Thread* self, Method* m, size_t frame_id)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // TODO: should we return the 'this' we passed through to non-static native methods?
   if (m->IsNative() || m->IsStatic()) {
     return NULL;
@@ -1627,12 +1703,21 @@
   return visitor.this_object;
 }
 
-JDWP::JdwpError Dbg::GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, JDWP::ObjectId* result) {
-  Thread* thread = DecodeThread(thread_id);
-  if (thread == NULL) {
-    return JDWP::ERR_INVALID_THREAD;
+JDWP::JdwpError Dbg::GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
+                                   JDWP::ObjectId* result) {
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread;
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    thread = DecodeThread(soa, thread_id);
+    if (thread == NULL) {
+      return JDWP::ERR_INVALID_THREAD;
+    }
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+    if (!thread->IsSuspended()) {
+      return JDWP::ERR_THREAD_NOT_SUSPENDED;
+    }
   }
-
   UniquePtr<Context> context(Context::Create());
   GetThisVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(), frame_id);
   visitor.WalkStack();
@@ -1640,15 +1725,19 @@
   return JDWP::ERR_NONE;
 }
 
-void Dbg::GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint8_t* buf, size_t width) {
+void Dbg::GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
+                        uint8_t* buf, size_t width) {
   struct GetLocalVisitor : public StackVisitor {
     GetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
                     Context* context, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
                     uint8_t* buf, size_t width)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : StackVisitor(stack, trace_stack, context), frame_id_(frameId), slot_(slot), tag_(tag),
           buf_(buf), width_(width) {}
 
-    bool VisitFrame() {
+    // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+    // annotalysis.
+    bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
       if (GetFrameId() != frame_id_) {
         return true;  // Not our frame, carry on.
       }
@@ -1746,7 +1835,9 @@
     uint8_t* const buf_;
     const size_t width_;
   };
-  Thread* thread = DecodeThread(threadId);
+
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread = DecodeThread(soa, threadId);
   UniquePtr<Context> context(Context::Create());
   GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
                           frameId, slot, tag, buf, width);
@@ -1759,10 +1850,13 @@
     SetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack, Context* context,
                     JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag, uint64_t value,
                     size_t width)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : StackVisitor(stack, trace_stack, context),
           frame_id_(frame_id), slot_(slot), tag_(tag), value_(value), width_(width) {}
 
-    bool VisitFrame() {
+    // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+    // annotalysis.
+    bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
       if (GetFrameId() != frame_id_) {
         return true;  // Not our frame, carry on.
       }
@@ -1817,7 +1911,9 @@
     const uint64_t value_;
     const size_t width_;
   };
-  Thread* thread = DecodeThread(threadId);
+
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread = DecodeThread(soa, threadId);
   UniquePtr<Context> context(Context::Create());
   SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
                           frameId, slot, tag, value, width);
@@ -2018,14 +2114,15 @@
   }
 }
 
-JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId threadId, JDWP::JdwpStepSize step_size, JDWP::JdwpStepDepth step_depth) {
-  Thread* thread = DecodeThread(threadId);
+JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId threadId, JDWP::JdwpStepSize step_size,
+                                   JDWP::JdwpStepDepth step_depth) {
+  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return JDWP::ERR_INVALID_THREAD;
   }
 
   MutexLock mu(gBreakpointsLock);
-
   // TODO: there's no theoretical reason why we couldn't support single-stepping
   // of multiple threads at once, but we never did so historically.
   if (gSingleStepControl.thread != NULL && thread != gSingleStepControl.thread) {
@@ -2041,14 +2138,18 @@
   struct SingleStepStackVisitor : public StackVisitor {
     SingleStepStackVisitor(const ManagedStack* stack,
                            const std::vector<TraceStackFrame>* trace_stack)
+        EXCLUSIVE_LOCKS_REQUIRED(gBreakpointsLock)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : StackVisitor(stack, trace_stack, NULL) {
-      MutexLock mu(gBreakpointsLock); // Keep GCC happy.
+      gBreakpointsLock.AssertHeld();
       gSingleStepControl.method = NULL;
       gSingleStepControl.stack_depth = 0;
     }
 
-    bool VisitFrame() {
-      MutexLock mu(gBreakpointsLock); // Keep GCC happy.
+    // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+    // annotalysis.
+    bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
+      gBreakpointsLock.AssertHeld();
       const Method* m = GetMethod();
       if (!m->IsRuntimeMethod()) {
         ++gSingleStepControl.stack_depth;
@@ -2185,14 +2286,21 @@
   }
 }
 
-JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId threadId, JDWP::ObjectId objectId, JDWP::RefTypeId classId, JDWP::MethodId methodId, uint32_t arg_count, uint64_t* arg_values, JDWP::JdwpTag* arg_types, uint32_t options, JDWP::JdwpTag* pResultTag, uint64_t* pResultValue, JDWP::ObjectId* pExceptionId) {
+JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId threadId, JDWP::ObjectId objectId,
+                                  JDWP::RefTypeId classId, JDWP::MethodId methodId,
+                                  uint32_t arg_count, uint64_t* arg_values,
+                                  JDWP::JdwpTag* arg_types, uint32_t options,
+                                  JDWP::JdwpTag* pResultTag, uint64_t* pResultValue,
+                                  JDWP::ObjectId* pExceptionId) {
   ThreadList* thread_list = Runtime::Current()->GetThreadList();
 
   Thread* targetThread = NULL;
   DebugInvokeReq* req = NULL;
+  Thread* self = Thread::Current();
   {
-    ScopedThreadListLock thread_list_lock;
-    targetThread = DecodeThread(threadId);
+    ScopedObjectAccessUnchecked soa(self);
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    targetThread = DecodeThread(soa, threadId);
     if (targetThread == NULL) {
       LOG(ERROR) << "InvokeMethod request for non-existent thread " << threadId;
       return JDWP::ERR_INVALID_THREAD;
@@ -2217,7 +2325,11 @@
      * by rejecting the method invocation request.  Without this, we will
      * be stuck waiting on a suspended thread.
      */
-    int suspend_count = targetThread->GetSuspendCount();
+    int suspend_count;
+    {
+      MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+      suspend_count = targetThread->GetSuspendCount();
+    }
     if (suspend_count > 1) {
       LOG(ERROR) << *targetThread << " suspend count too deep for method invocation: " << suspend_count;
       return JDWP::ERR_THREAD_SUSPENDED; // Probably not expected here.
@@ -2287,7 +2399,7 @@
      * run out of memory.  It's also a good idea to change it before locking
      * the invokeReq mutex, although that should never be held for long.
      */
-    ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
+    self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
 
     VLOG(jdwp) << "    Transferring control to event thread";
     {
@@ -2295,7 +2407,7 @@
 
       if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
         VLOG(jdwp) << "      Resuming all threads";
-        thread_list->ResumeAll(true);
+        thread_list->UndoDebuggerSuspensions();
       } else {
         VLOG(jdwp) << "      Resuming event thread only";
         thread_list->Resume(targetThread, true);
@@ -2309,8 +2421,8 @@
     VLOG(jdwp) << "    Control has returned from event thread";
 
     /* wait for thread to re-suspend itself */
-    targetThread->WaitUntilSuspended();
-    //dvmWaitForSuspend(targetThread);
+    SuspendThread(threadId, false /* request_suspension */ );
+    self->TransitionFromSuspendedToRunnable();
   }
 
   /*
@@ -2321,8 +2433,10 @@
    * so we want to resume the target thread once to keep the books straight.
    */
   if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
+    self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSuspension);
     VLOG(jdwp) << "      Suspending all threads";
-    thread_list->SuspendAll(true);
+    thread_list->SuspendAllForDebugger();
+    self->TransitionFromSuspendedToRunnable();
     VLOG(jdwp) << "      Resuming event thread to balance the count";
     thread_list->Resume(targetThread, true);
   }
@@ -2339,12 +2453,12 @@
 }
 
 void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccess soa(Thread::Current());
 
   // We can be called while an exception is pending. We need
   // to preserve that across the method invocation.
-  SirtRef<Throwable> old_exception(ts.Self()->GetException());
-  ts.Self()->ClearException();
+  SirtRef<Throwable> old_exception(soa.Self()->GetException());
+  soa.Self()->ClearException();
 
   // Translate the method through the vtable, unless the debugger wants to suppress it.
   Method* m = pReq->method_;
@@ -2360,15 +2474,17 @@
 
   CHECK_EQ(sizeof(jvalue), sizeof(uint64_t));
 
-  LOG(INFO) << "self=" << ts.Self() << " pReq->receiver_=" << pReq->receiver_ << " m=" << m << " #" << pReq->arg_count_ << " " << pReq->arg_values_;
-  pReq->result_value = InvokeWithJValues(ts, pReq->receiver_, m, reinterpret_cast<JValue*>(pReq->arg_values_));
+  LOG(INFO) << "self=" << soa.Self() << " pReq->receiver_=" << pReq->receiver_ << " m=" << m
+      << " #" << pReq->arg_count_ << " " << pReq->arg_values_;
+  pReq->result_value = InvokeWithJValues(soa, pReq->receiver_, m,
+                                         reinterpret_cast<JValue*>(pReq->arg_values_));
 
-  pReq->exception = gRegistry->Add(ts.Self()->GetException());
+  pReq->exception = gRegistry->Add(soa.Self()->GetException());
   pReq->result_tag = BasicTagFromDescriptor(MethodHelper(m).GetShorty());
   if (pReq->exception != 0) {
-    Object* exc = ts.Self()->GetException();
+    Object* exc = soa.Self()->GetException();
     VLOG(jdwp) << "  JDWP invocation returning with exception=" << exc << " " << PrettyTypeOf(exc);
-    ts.Self()->ClearException();
+    soa.Self()->ClearException();
     pReq->result_value.SetJ(0);
   } else if (pReq->result_tag == JDWP::JT_OBJECT) {
     /* if no exception thrown, examine object result more closely */
@@ -2391,7 +2507,7 @@
   }
 
   if (old_exception.get() != NULL) {
-    ts.Self()->SetException(old_exception.get());
+    soa.Self()->SetException(old_exception.get());
   }
 }
 
@@ -2507,9 +2623,12 @@
   VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
 
   Thread* self = Thread::Current();
-  if (self->GetState() != kRunnable) {
-    LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
-    /* try anyway? */
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    if (self->GetState() != kRunnable) {
+      LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
+      /* try anyway? */
+    }
   }
 
   JNIEnv* env = self->GetJniEnv();
@@ -2550,8 +2669,8 @@
     Dbg::DdmSendChunk(CHUNK_TYPE("THDE"), 4, buf);
   } else {
     CHECK(type == CHUNK_TYPE("THCR") || type == CHUNK_TYPE("THNM")) << type;
-    ScopedJniThreadState ts(Thread::Current());
-    SirtRef<String> name(t->GetThreadName(ts));
+    ScopedObjectAccessUnchecked soa(Thread::Current());
+    SirtRef<String> name(t->GetThreadName(soa));
     size_t char_count = (name.get() != NULL) ? name->GetLength() : 0;
     const jchar* chars = name->GetCharArray()->GetData();
 
@@ -2563,19 +2682,27 @@
   }
 }
 
-static void DdmSendThreadStartCallback(Thread* t, void*) {
-  Dbg::DdmSendThreadNotification(t, CHUNK_TYPE("THCR"));
-}
-
 void Dbg::DdmSetThreadNotification(bool enable) {
-  // We lock the thread list to avoid sending duplicate events or missing
-  // a thread change. We should be okay holding this lock while sending
-  // the messages out. (We have to hold it while accessing a live thread.)
-  ScopedThreadListLock thread_list_lock;
-
+  // Enable/disable thread notifications.
   gDdmThreadNotification = enable;
   if (enable) {
-    Runtime::Current()->GetThreadList()->ForEach(DdmSendThreadStartCallback, NULL);
+    // Suspend the VM then post thread start notifications for all threads. Threads attaching will
+    // see a suspension in progress and block until that ends. They then post their own start
+    // notification.
+    SuspendVM();
+    std::list<Thread*> threads;
+    {
+      MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+      threads = Runtime::Current()->GetThreadList()->GetList();
+    }
+    {
+      ScopedObjectAccess soa(Thread::Current());
+      typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
+      for (It it = threads.begin(), end = threads.end(); it != end; ++it) {
+        Dbg::DdmSendThreadNotification(*it, CHUNK_TYPE("THCR"));
+      }
+    }
+    ResumeVM();
   }
 }
 
@@ -2758,7 +2885,7 @@
     needHeader_ = false;
   }
 
-  void Flush() {
+  void Flush() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // Patch the "length of piece" field.
     CHECK_LE(&buf_[0], pieceLenField_);
     CHECK_LE(pieceLenField_, p_);
@@ -2768,7 +2895,8 @@
     Reset();
   }
 
-  static void HeapChunkCallback(void* start, void* end, size_t used_bytes, void* arg) {
+  static void HeapChunkCallback(void* start, void* end, size_t used_bytes, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     reinterpret_cast<HeapChunkContext*>(arg)->HeapChunkCallback(start, end, used_bytes);
   }
 
@@ -2782,7 +2910,8 @@
     pieceLenField_ = NULL;
   }
 
-  void HeapChunkCallback(void* start, void* /*end*/, size_t used_bytes) {
+  void HeapChunkCallback(void* start, void* /*end*/, size_t used_bytes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // Note: heap call backs cannot manipulate the heap upon which they are crawling, care is taken
     // in the following code not to allocate memory, by ensuring buf_ is of the correct size
 
@@ -2834,10 +2963,17 @@
 
     // If we're looking at the native heap, we'll just return
     // (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks.
-    if (is_native_heap || !Runtime::Current()->GetHeap()->IsLiveObjectLocked(o)) {
+    if (is_native_heap) {
       return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
     }
 
+    {
+      ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      if (!Runtime::Current()->GetHeap()->IsLiveObjectLocked(o)) {
+        return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
+      }
+    }
+
     Class* c = o->GetClass();
     if (c == NULL) {
       // The object was probably just created but hasn't been initialized yet.
@@ -2942,9 +3078,12 @@
 struct AllocRecordStackVisitor : public StackVisitor {
   AllocRecordStackVisitor(const ManagedStack* stack,
                           const std::vector<TraceStackFrame>* trace_stack, AllocRecord* record)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(stack, trace_stack, NULL), record(record), depth(0) {}
 
-  bool VisitFrame() {
+  // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
+  // annotalysis.
+  bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
     if (depth >= kMaxAllocRecordStackDepth) {
       return false;
     }
@@ -3011,6 +3150,7 @@
 }
 
 void Dbg::DumpRecentAllocations() {
+  ScopedObjectAccess soa(Thread::Current());
   MutexLock mu(gAllocTrackerLock);
   if (recent_allocation_records_ == NULL) {
     LOG(INFO) << "Not recording tracked allocations";
diff --git a/src/debugger.h b/src/debugger.h
index 4c0c1b6..4db9bd7 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -38,7 +38,10 @@
  */
 struct DebugInvokeReq {
   DebugInvokeReq()
-      : invoke_needed_(false),
+      : ready(false), invoke_needed_(false),
+        receiver_(NULL), thread_(NULL), class_(NULL), method_(NULL),
+        arg_count_(0), arg_values_(NULL), options_(0), error(JDWP::ERR_NONE),
+        result_tag(JDWP::JT_VOID), exception(0),
         lock_("a DebugInvokeReq lock"),
         cond_("a DebugInvokeReq condition variable") {
   }
@@ -78,7 +81,7 @@
   static void StopJdwp();
 
   // Invoked by the GC in case we need to keep DDMS informed.
-  static void GcDidFinish();
+  static void GcDidFinish() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Return the DebugInvokeReq for the current thread.
   static DebugInvokeReq* GetInvokeReq();
@@ -111,15 +114,6 @@
    */
   static int64_t LastDebuggerActivity();
 
-  /*
-   * Block/allow GC depending on what we're doing.  These return the old
-   * status, which can be fed to ThreadContinuing() to restore the previous
-   * mode.
-   */
-  static int ThreadRunning();
-  static int ThreadWaiting();
-  static int ThreadContinuing(int status);
-
   static void UndoDebuggerSuspensions();
 
   static void Exit(int status);
@@ -129,84 +123,154 @@
   /*
    * Class, Object, Array
    */
-  static std::string GetClassName(JDWP::RefTypeId id);
-  static JDWP::JdwpError GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId& classObjectId);
-  static JDWP::JdwpError GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId& superclassId);
-  static JDWP::JdwpError GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError GetReflectedType(JDWP::RefTypeId classId, JDWP::ExpandBuf* pReply);
-  static void GetClassList(std::vector<JDWP::RefTypeId>& classes);
-  static JDWP::JdwpError GetClassInfo(JDWP::RefTypeId classId, JDWP::JdwpTypeTag* pTypeTag, uint32_t* pStatus, std::string* pDescriptor);
-  static void FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>& ids);
+  static std::string GetClassName(JDWP::RefTypeId id)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId& classObjectId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId& superclassId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetReflectedType(JDWP::RefTypeId classId, JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void GetClassList(std::vector<JDWP::RefTypeId>& classes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetClassInfo(JDWP::RefTypeId classId, JDWP::JdwpTypeTag* pTypeTag,
+                                      uint32_t* pStatus, std::string* pDescriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>& ids)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static JDWP::JdwpError GetReferenceType(JDWP::ObjectId objectId, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError GetSignature(JDWP::RefTypeId refTypeId, std::string& signature);
-  static JDWP::JdwpError GetSourceFile(JDWP::RefTypeId refTypeId, std::string& source_file);
-  static JDWP::JdwpError GetObjectTag(JDWP::ObjectId objectId, uint8_t& tag);
+  static JDWP::JdwpError GetSignature(JDWP::RefTypeId refTypeId, std::string& signature)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetSourceFile(JDWP::RefTypeId refTypeId, std::string& source_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetObjectTag(JDWP::ObjectId objectId, uint8_t& tag)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static size_t GetTagWidth(JDWP::JdwpTag tag);
 
-  static JDWP::JdwpError GetArrayLength(JDWP::ObjectId arrayId, int& length);
-  static JDWP::JdwpError OutputArray(JDWP::ObjectId arrayId, int firstIndex, int count, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError SetArrayElements(JDWP::ObjectId arrayId, int firstIndex, int count, const uint8_t* buf);
+  static JDWP::JdwpError GetArrayLength(JDWP::ObjectId arrayId, int& length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError OutputArray(JDWP::ObjectId arrayId, int firstIndex, int count,
+                                     JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError SetArrayElements(JDWP::ObjectId arrayId, int firstIndex, int count,
+                                          const uint8_t* buf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static JDWP::ObjectId CreateString(const std::string& str);
-  static JDWP::JdwpError CreateObject(JDWP::RefTypeId classId, JDWP::ObjectId& new_object);
-  static JDWP::JdwpError CreateArrayObject(JDWP::RefTypeId arrayTypeId, uint32_t length, JDWP::ObjectId& new_array);
+  static JDWP::ObjectId CreateString(const std::string& str)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError CreateObject(JDWP::RefTypeId classId, JDWP::ObjectId& new_object)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError CreateArrayObject(JDWP::RefTypeId arrayTypeId, uint32_t length,
+                                           JDWP::ObjectId& new_array)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static bool MatchType(JDWP::RefTypeId instClassId, JDWP::RefTypeId classId);
+  static bool MatchType(JDWP::RefTypeId instClassId, JDWP::RefTypeId classId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Method and Field
    */
-  static std::string GetMethodName(JDWP::RefTypeId refTypeId, JDWP::MethodId id);
-  static JDWP::JdwpError OutputDeclaredFields(JDWP::RefTypeId refTypeId, bool withGeneric, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError OutputDeclaredMethods(JDWP::RefTypeId refTypeId, bool withGeneric, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError OutputDeclaredInterfaces(JDWP::RefTypeId refTypeId, JDWP::ExpandBuf* pReply);
-  static void OutputLineTable(JDWP::RefTypeId refTypeId, JDWP::MethodId methodId, JDWP::ExpandBuf* pReply);
-  static void OutputVariableTable(JDWP::RefTypeId refTypeId, JDWP::MethodId id, bool withGeneric, JDWP::ExpandBuf* pReply);
+  static std::string GetMethodName(JDWP::RefTypeId refTypeId, JDWP::MethodId id)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError OutputDeclaredFields(JDWP::RefTypeId refTypeId, bool withGeneric,
+                                              JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError OutputDeclaredMethods(JDWP::RefTypeId refTypeId, bool withGeneric,
+                                               JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError OutputDeclaredInterfaces(JDWP::RefTypeId refTypeId,
+                                                  JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void OutputLineTable(JDWP::RefTypeId refTypeId, JDWP::MethodId methodId,
+                              JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void OutputVariableTable(JDWP::RefTypeId refTypeId, JDWP::MethodId id, bool withGeneric,
+                                  JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static JDWP::JdwpTag GetFieldBasicTag(JDWP::FieldId fieldId);
-  static JDWP::JdwpTag GetStaticFieldBasicTag(JDWP::FieldId fieldId);
-  static JDWP::JdwpError GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError SetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, uint64_t value, int width);
-  static JDWP::JdwpError GetStaticFieldValue(JDWP::RefTypeId refTypeId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply);
-  static JDWP::JdwpError SetStaticFieldValue(JDWP::FieldId fieldId, uint64_t value, int width);
+  static JDWP::JdwpTag GetFieldBasicTag(JDWP::FieldId fieldId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpTag GetStaticFieldBasicTag(JDWP::FieldId fieldId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);;
+  static JDWP::JdwpError GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
+                                       JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError SetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
+                                       uint64_t value, int width)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError GetStaticFieldValue(JDWP::RefTypeId refTypeId, JDWP::FieldId fieldId,
+                                             JDWP::ExpandBuf* pReply)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError SetStaticFieldValue(JDWP::FieldId fieldId, uint64_t value, int width)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static std::string StringToUtf8(JDWP::ObjectId strId);
+  static std::string StringToUtf8(JDWP::ObjectId strId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Thread, ThreadGroup, Frame
    */
-  static bool GetThreadName(JDWP::ObjectId threadId, std::string& name);
+  static bool GetThreadName(JDWP::ObjectId threadId, std::string& name)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_);
   static JDWP::JdwpError GetThreadGroup(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply);
   static std::string GetThreadGroupName(JDWP::ObjectId threadGroupId);
-  static JDWP::ObjectId GetThreadGroupParent(JDWP::ObjectId threadGroupId);
-  static JDWP::ObjectId GetSystemThreadGroupId();
+  static JDWP::ObjectId GetThreadGroupParent(JDWP::ObjectId threadGroupId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::ObjectId GetSystemThreadGroupId()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static JDWP::ObjectId GetMainThreadGroupId();
 
   static bool GetThreadStatus(JDWP::ObjectId threadId, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus);
-  static JDWP::JdwpError GetThreadSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply);
+  static JDWP::JdwpError GetThreadDebugSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply);
   static bool ThreadExists(JDWP::ObjectId threadId);
   static bool IsSuspended(JDWP::ObjectId threadId);
   //static void WaitForSuspend(JDWP::ObjectId threadId);
 
   // Fills 'thread_ids' with the threads in the given thread group. If thread_group_id == 0,
   // returns all threads.
-  static void GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids);
+  static void GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& child_thread_group_ids);
 
   static int GetThreadFrameCount(JDWP::ObjectId threadId);
-  static JDWP::JdwpError GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf);
+  static JDWP::JdwpError GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame,
+                                         size_t frame_count, JDWP::ExpandBuf* buf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static JDWP::ObjectId GetThreadSelfId();
-  static void SuspendVM();
+  static JDWP::ObjectId GetThreadSelfId()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void SuspendVM()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
   static void ResumeVM();
-  static void SuspendThread(JDWP::ObjectId threadId);
-  static void ResumeThread(JDWP::ObjectId threadId);
+  static JDWP::JdwpError SuspendThread(JDWP::ObjectId threadId, bool request_suspension = true)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+
+  static void ResumeThread(JDWP::ObjectId threadId)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void SuspendSelf();
 
-  static JDWP::JdwpError GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, JDWP::ObjectId* result);
-  static void GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint8_t* buf, size_t expectedLen);
-  static void SetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint64_t value, size_t width);
+  static JDWP::JdwpError GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
+                                       JDWP::ObjectId* result)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot,
+                            JDWP::JdwpTag tag, uint8_t* buf, size_t expectedLen)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void SetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot,
+                            JDWP::JdwpTag tag, uint64_t value, size_t width)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Debugger notification
@@ -217,20 +281,41 @@
     kMethodEntry    = 0x04,
     kMethodExit     = 0x08,
   };
-  static void PostLocationEvent(const Method* method, int pcOffset, Object* thisPtr, int eventFlags);
-  static void PostException(Thread* thread, JDWP::FrameId throw_frame_id, Method* throw_method, uint32_t throw_dex_pc, Method* catch_method, uint32_t catch_dex_pc, Throwable* exception);
-  static void PostThreadStart(Thread* t);
-  static void PostThreadDeath(Thread* t);
-  static void PostClassPrepare(Class* c);
+  static void PostLocationEvent(const Method* method, int pcOffset, Object* thisPtr, int eventFlags)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void PostException(Thread* thread, JDWP::FrameId throw_frame_id, Method* throw_method,
+                            uint32_t throw_dex_pc, Method* catch_method, uint32_t catch_dex_pc,
+                            Throwable* exception)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void PostThreadStart(Thread* t)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void PostThreadDeath(Thread* t)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void PostClassPrepare(Class* c)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static void UpdateDebugger(int32_t dex_pc, Thread* self);
+  static void UpdateDebugger(int32_t dex_pc, Thread* self)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static void WatchLocation(const JDWP::JdwpLocation* pLoc);
-  static void UnwatchLocation(const JDWP::JdwpLocation* pLoc);
-  static JDWP::JdwpError ConfigureStep(JDWP::ObjectId threadId, JDWP::JdwpStepSize size, JDWP::JdwpStepDepth depth);
+  static void WatchLocation(const JDWP::JdwpLocation* pLoc)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void UnwatchLocation(const JDWP::JdwpLocation* pLoc)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static JDWP::JdwpError ConfigureStep(JDWP::ObjectId threadId, JDWP::JdwpStepSize size,
+                                       JDWP::JdwpStepDepth depth)
+      LOCKS_EXCLUDED(gBreakpointsLock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void UnconfigureStep(JDWP::ObjectId threadId);
 
-  static JDWP::JdwpError InvokeMethod(JDWP::ObjectId threadId, JDWP::ObjectId objectId, JDWP::RefTypeId classId, JDWP::MethodId methodId, uint32_t arg_count, uint64_t* arg_values, JDWP::JdwpTag* arg_types, uint32_t options, JDWP::JdwpTag* pResultTag, uint64_t* pResultValue, JDWP::ObjectId* pExceptObj);
+  static JDWP::JdwpError InvokeMethod(JDWP::ObjectId threadId, JDWP::ObjectId objectId,
+                                      JDWP::RefTypeId classId, JDWP::MethodId methodId,
+                                      uint32_t arg_count, uint64_t* arg_values,
+                                      JDWP::JdwpTag* arg_types, uint32_t options,
+                                      JDWP::JdwpTag* pResultTag, uint64_t* pResultValue,
+                                      JDWP::ObjectId* pExceptObj)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void ExecuteMethod(DebugInvokeReq* pReq);
 
   /* perform "late registration" of an object ID */
@@ -239,22 +324,28 @@
   /*
    * DDM support.
    */
-  static void DdmSendThreadNotification(Thread* t, uint32_t type);
+  static void DdmSendThreadNotification(Thread* t, uint32_t type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void DdmSetThreadNotification(bool enable);
   static bool DdmHandlePacket(const uint8_t* buf, int dataLen, uint8_t** pReplyBuf, int* pReplyLen);
-  static void DdmConnected();
-  static void DdmDisconnected();
-  static void DdmSendChunk(uint32_t type, const std::vector<uint8_t>& bytes);
-  static void DdmSendChunk(uint32_t type, size_t len, const uint8_t* buf);
-  static void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count);
+  static void DdmConnected() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DdmDisconnected() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DdmSendChunk(uint32_t type, const std::vector<uint8_t>& bytes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DdmSendChunk(uint32_t type, size_t len, const uint8_t* buf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Recent allocation tracking support.
    */
-  static void RecordAllocation(Class* type, size_t byte_count);
+  static void RecordAllocation(Class* type, size_t byte_count)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void SetAllocTrackingEnabled(bool enabled);
   static inline bool IsAllocTrackingEnabled() { return recent_allocation_records_ != NULL; }
-  static jbyteArray GetRecentAllocations();
+  static jbyteArray GetRecentAllocations()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static void DumpRecentAllocations();
 
   enum HpifWhen {
@@ -263,7 +354,8 @@
     HPIF_WHEN_NEXT_GC = 2,
     HPIF_WHEN_EVERY_GC = 3
   };
-  static int DdmHandleHpifChunk(HpifWhen when);
+  static int DdmHandleHpifChunk(HpifWhen when)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   enum HpsgWhen {
     HPSG_WHEN_NEVER = 0,
@@ -275,12 +367,15 @@
   };
   static bool DdmHandleHpsgNhsgChunk(HpsgWhen when, HpsgWhat what, bool native);
 
-  static void DdmSendHeapInfo(HpifWhen reason);
-  static void DdmSendHeapSegments(bool native);
+  static void DdmSendHeapInfo(HpifWhen reason)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DdmSendHeapSegments(bool native)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
-  static void DdmBroadcast(bool);
-  static void PostThreadStartOrStop(Thread*, uint32_t);
+  static void DdmBroadcast(bool) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void PostThreadStartOrStop(Thread*, uint32_t)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static AllocRecord* recent_allocation_records_;
 };
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 4587b30..b68a75b 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -33,9 +33,12 @@
 #include "object_utils.h"
 #include "os.h"
 #include "runtime.h"
+#include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "stl_util.h"
 #include "stringpiece.h"
 #include "timing_logger.h"
+#include "well_known_classes.h"
 #include "zip_archive.h"
 
 namespace art {
@@ -118,13 +121,15 @@
 
 class Dex2Oat {
  public:
-  static Dex2Oat* Create(Runtime::Options& options, InstructionSet instruction_set,
-                         size_t thread_count, bool support_debugging) {
-    UniquePtr<Runtime> runtime(CreateRuntime(options, instruction_set));
-    if (runtime.get() == NULL) {
-      return NULL;
+  static bool Create(Dex2Oat** p_dex2oat, Runtime::Options& options, InstructionSet instruction_set,
+                         size_t thread_count, bool support_debugging)
+      SHARED_TRYLOCK_FUNCTION(true, GlobalSynchronization::mutator_lock_) {
+    if (!CreateRuntime(options, instruction_set)) {
+      *p_dex2oat = NULL;
+      return false;
     }
-    return new Dex2Oat(runtime.release(), instruction_set, thread_count, support_debugging);
+    *p_dex2oat = new Dex2Oat(Runtime::Current(), instruction_set, thread_count, support_debugging);
+    return true;
   }
 
   ~Dex2Oat() {
@@ -133,7 +138,8 @@
   }
 
   // Make a list of descriptors for classes to include in the image
-  const std::set<std::string>* GetImageClassDescriptors(const char* image_classes_filename) {
+  const std::set<std::string>* GetImageClassDescriptors(const char* image_classes_filename)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     UniquePtr<std::ifstream> image_classes_file(new std::ifstream(image_classes_filename, std::ifstream::in));
     if (image_classes_file.get() == NULL) {
       LOG(ERROR) << "Failed to open image classes file " << image_classes_filename;
@@ -206,14 +212,10 @@
                                 bool image,
                                 const std::set<std::string>* image_classes,
                                 bool dump_stats,
-                                bool dump_timings) {
+                                bool dump_timings)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // SirtRef and ClassLoader creation needs to come after Runtime::Create
-    UniquePtr<SirtRef<ClassLoader> > class_loader(new SirtRef<ClassLoader>(NULL));
-    if (class_loader.get() == NULL) {
-      LOG(ERROR) << "Failed to create SirtRef for class loader";
-      return NULL;
-    }
-
+    jobject class_loader = NULL;
     if (!boot_image_option.empty()) {
       ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
       std::vector<const DexFile*> class_path_files(dex_files);
@@ -221,7 +223,12 @@
       for (size_t i = 0; i < class_path_files.size(); i++) {
         class_linker->RegisterDexFile(*class_path_files[i]);
       }
-      class_loader.get()->reset(PathClassLoader::AllocCompileTime(class_path_files));
+      ScopedObjectAccessUnchecked soa(Thread::Current());
+      soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader);
+      ScopedLocalRef<jobject> class_loader_local(soa.Env(),
+          soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
+      class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
+      Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path_files);
     }
 
     UniquePtr<Compiler> compiler(new Compiler(instruction_set_,
@@ -236,7 +243,11 @@
     compiler->SetBitcodeFileName(bitcode_filename);
 #endif
 
-    compiler->CompileAll(class_loader->get(), dex_files);
+    Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+
+    compiler->CompileAll(class_loader, dex_files);
+
+    Thread::Current()->TransitionFromSuspendedToRunnable();
 
     std::string image_file_location;
     uint32_t image_file_location_checksum = 0;
@@ -251,7 +262,7 @@
     }
 
     if (!OatWriter::Create(oat_file,
-                           class_loader->get(),
+                           class_loader,
                            dex_files,
                            image_file_location_checksum,
                            image_file_location,
@@ -267,7 +278,8 @@
                        const std::set<std::string>* image_classes,
                        const std::string& oat_filename,
                        const std::string& oat_location,
-                       const Compiler& compiler) {
+                       const Compiler& compiler)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
     ImageWriter image_writer(image_classes);
     if (!image_writer.Write(image_filename, image_base, oat_filename, oat_location, compiler)) {
       LOG(ERROR) << "Failed to create image file " << image_filename;
@@ -286,13 +298,13 @@
         start_ns_(NanoTime()) {
   }
 
-  static Runtime* CreateRuntime(Runtime::Options& options, InstructionSet instruction_set) {
-    Runtime* runtime = Runtime::Create(options, false);
-    if (runtime == NULL) {
+  static bool CreateRuntime(Runtime::Options& options, InstructionSet instruction_set)
+      SHARED_TRYLOCK_FUNCTION(true, GlobalSynchronization::mutator_lock_) {
+    if (!Runtime::Create(options, false)) {
       LOG(ERROR) << "Failed to create runtime";
-      return NULL;
+      return false;
     }
-
+    Runtime* runtime = Runtime::Current();
     // if we loaded an existing image, we will reuse values from the image roots.
     if (!runtime->HasJniDlsymLookupStub()) {
       runtime->SetJniDlsymLookupStub(Compiler::CreateJniDlsymLookupStub(instruction_set));
@@ -316,11 +328,12 @@
       }
     }
     runtime->GetClassLinker()->FixupDexCaches(runtime->GetResolutionMethod());
-    return runtime;
+    return true;
   }
 
   static void ResolveExceptionsForMethod(MethodHelper* mh,
-                           std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve) {
+                           std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile::CodeItem* code_item = mh->GetCodeItem();
     if (code_item == NULL) {
       return;  // native or abstract method
@@ -355,7 +368,9 @@
       }
     }
   }
-  static bool ResolveCatchBlockExceptionsClassVisitor(Class* c, void* arg) {
+
+  static bool ResolveCatchBlockExceptionsClassVisitor(Class* c, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
         reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
     MethodHelper mh;
@@ -371,7 +386,9 @@
     }
     return true;
   }
-  static bool RecordImageClassesVisitor(Class* klass, void* arg) {
+
+  static bool RecordImageClassesVisitor(Class* klass, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::set<std::string>* image_classes = reinterpret_cast<std::set<std::string>*>(arg);
     if (klass->IsArrayClass() || klass->IsPrimitive()) {
       return true;
@@ -684,8 +701,18 @@
     options.push_back(std::make_pair(runtime_args[i], reinterpret_cast<void*>(NULL)));
   }
 
-  UniquePtr<Dex2Oat> dex2oat(Dex2Oat::Create(options, instruction_set, thread_count,
-                                             support_debugging));
+  Dex2Oat* p_dex2oat;
+  if (!Dex2Oat::Create(&p_dex2oat, options, instruction_set, thread_count, support_debugging)) {
+    LOG(ERROR) << "Failed to create dex2oat";
+    return EXIT_FAILURE;
+  }
+  UniquePtr<Dex2Oat> dex2oat(p_dex2oat);
+  // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
+  // give it away now and then switch to a more managable ScopedObjectAccess.
+  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  // Whilst we're in native take the opportunity to initialize well known classes.
+  WellKnownClasses::InitClasses(Thread::Current()->GetJniEnv());
+  ScopedObjectAccess soa(Thread::Current());
 
   // If --image-classes was specified, calculate the full list of classes to include in the image
   UniquePtr<const std::set<std::string> > image_classes(NULL);
@@ -744,12 +771,15 @@
     return EXIT_SUCCESS;
   }
 
-  if (!dex2oat->CreateImageFile(image_filename,
-                                image_base,
-                                image_classes.get(),
-                                oat_filename,
-                                oat_location,
-                                *compiler.get())) {
+  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  bool image_creation_success = dex2oat->CreateImageFile(image_filename,
+                                                         image_base,
+                                                         image_classes.get(),
+                                                         oat_filename,
+                                                         oat_location,
+                                                         *compiler.get());
+  Thread::Current()->TransitionFromSuspendedToRunnable();
+  if (!image_creation_success) {
     return EXIT_FAILURE;
   }
 
diff --git a/src/dex_cache.h b/src/dex_cache.h
index f604701..b3c5ce6 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -38,11 +38,12 @@
             ObjectArray<Class>* types,
             ObjectArray<Method>* methods,
             ObjectArray<Field>* fields,
-            ObjectArray<StaticStorageBase>* initialized_static_storage);
+            ObjectArray<StaticStorageBase>* initialized_static_storage)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Fixup(Method* trampoline);
+  void Fixup(Method* trampoline) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  String* GetLocation() const {
+  String* GetLocation() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return Get(kLocation)->AsString();
   }
 
@@ -61,43 +62,49 @@
                         kResolvedMethods * sizeof(Object*));
   }
 
-  size_t NumStrings() const {
+  size_t NumStrings() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetStrings()->GetLength();
   }
 
-  size_t NumResolvedTypes() const {
+  size_t NumResolvedTypes() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetResolvedTypes()->GetLength();
   }
 
-  size_t NumResolvedMethods() const {
+  size_t NumResolvedMethods() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetResolvedMethods()->GetLength();
   }
 
-  size_t NumResolvedFields() const {
+  size_t NumResolvedFields() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetResolvedFields()->GetLength();
   }
 
-  size_t NumInitializedStaticStorage() const {
+  size_t NumInitializedStaticStorage() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetInitializedStaticStorage()->GetLength();
   }
 
-  String* GetResolvedString(uint32_t string_idx) const {
+  String* GetResolvedString(uint32_t string_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetStrings()->Get(string_idx);
   }
 
-  void SetResolvedString(uint32_t string_idx, String* resolved) {
+  void SetResolvedString(uint32_t string_idx, String* resolved)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     GetStrings()->Set(string_idx, resolved);
   }
 
-  Class* GetResolvedType(uint32_t type_idx) const {
+  Class* GetResolvedType(uint32_t type_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetResolvedTypes()->Get(type_idx);
   }
 
-  void SetResolvedType(uint32_t type_idx, Class* resolved) {
+  void SetResolvedType(uint32_t type_idx, Class* resolved)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     GetResolvedTypes()->Set(type_idx, resolved);
   }
 
-  Method* GetResolvedMethod(uint32_t method_idx) const {
+  Method* GetResolvedMethod(uint32_t method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method = GetResolvedMethods()->Get(method_idx);
     // Hide resolution trampoline methods from the caller
     if (method != NULL && method->GetDexMethodIndex() == DexFile::kDexNoIndex16) {
@@ -108,31 +115,39 @@
     }
   }
 
-  void SetResolvedMethod(uint32_t method_idx, Method* resolved) {
+  void SetResolvedMethod(uint32_t method_idx, Method* resolved)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     GetResolvedMethods()->Set(method_idx, resolved);
   }
 
-  Field* GetResolvedField(uint32_t field_idx) const {
+  Field* GetResolvedField(uint32_t field_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetResolvedFields()->Get(field_idx);
   }
 
-  void SetResolvedField(uint32_t field_idx, Field* resolved) {
+  void SetResolvedField(uint32_t field_idx, Field* resolved)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     GetResolvedFields()->Set(field_idx, resolved);
   }
 
-  ObjectArray<String>* GetStrings() const {
+  ObjectArray<String>* GetStrings() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return static_cast<ObjectArray<String>*>(GetNonNull(kStrings));
   }
-  ObjectArray<Class>* GetResolvedTypes() const {
+  ObjectArray<Class>* GetResolvedTypes() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return static_cast<ObjectArray<Class>*>(GetNonNull(kResolvedTypes));
   }
-  ObjectArray<Method>* GetResolvedMethods() const {
+  ObjectArray<Method>* GetResolvedMethods() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return static_cast<ObjectArray<Method>*>(GetNonNull(kResolvedMethods));
   }
-  ObjectArray<Field>* GetResolvedFields() const {
+  ObjectArray<Field>* GetResolvedFields() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return static_cast<ObjectArray<Field>*>(GetNonNull(kResolvedFields));
   }
-  ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const {
+  ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return static_cast<ObjectArray<StaticStorageBase>*>(GetNonNull(kInitializedStaticStorage));
   }
 
@@ -151,7 +166,8 @@
     kMax                      = 6,
   };
 
-  Object* GetNonNull(ArrayIndex array_index) const {
+  Object* GetNonNull(ArrayIndex array_index) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Object* obj = Get(array_index);
     DCHECK(obj != NULL);
     return obj;
diff --git a/src/dex_cache_test.cc b/src/dex_cache_test.cc
index 6340d79..da02125 100644
--- a/src/dex_cache_test.cc
+++ b/src/dex_cache_test.cc
@@ -27,6 +27,7 @@
 class DexCacheTest : public CommonTest {};
 
 TEST_F(DexCacheTest, Open) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<DexCache> dex_cache(class_linker_->AllocDexCache(*java_lang_dex_file_));
   ASSERT_TRUE(dex_cache.get() != NULL);
 
diff --git a/src/dex_file.cc b/src/dex_file.cc
index 2b81e72..e763e67 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -220,18 +220,37 @@
   // the global reference table is otherwise empty!
 }
 
-jobject DexFile::GetDexObject(JNIEnv* env) const {
-  MutexLock mu(dex_object_lock_);
-  if (dex_object_ != NULL) {
-    return dex_object_;
+class ScopedJniMonitorLock {
+ public:
+  ScopedJniMonitorLock(JNIEnv* env, jobject locked) : env_(env), locked_(locked){
+    env->MonitorEnter(locked_);
   }
+  ~ScopedJniMonitorLock() {
+    env_->MonitorExit(locked_);
+  }
+ private:
+  JNIEnv* const env_;
+  const jobject locked_;
+};
 
+jobject DexFile::GetDexObject(JNIEnv* env) const {
+  {
+    ScopedJniMonitorLock lock(env, WellKnownClasses::com_android_dex_Dex);
+    if (dex_object_ != NULL) {
+      return dex_object_;
+    }
+  }
   void* address = const_cast<void*>(reinterpret_cast<const void*>(begin_));
   jobject byte_buffer = env->NewDirectByteBuffer(address, size_);
   if (byte_buffer == NULL) {
     return NULL;
   }
 
+  ScopedJniMonitorLock lock(env, WellKnownClasses::com_android_dex_Dex);
+  // Re-test to see if someone beat us to the creation when we had the lock released.
+  if (dex_object_ != NULL) {
+    return dex_object_;
+  }
   jvalue args[1];
   args[0].l = byte_buffer;
   jobject local = env->CallStaticObjectMethodA(WellKnownClasses::com_android_dex_Dex,
diff --git a/src/dex_file.h b/src/dex_file.h
index f1f76a8..5f33ef8 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -773,7 +773,8 @@
   // Returns -2 for native methods (as expected in exception traces).
   //
   // This is used by runtime; therefore use art::Method not art::DexFile::Method.
-  int32_t GetLineNumFromPC(const Method* method, uint32_t rel_pc) const;
+  int32_t GetLineNumFromPC(const Method* method, uint32_t rel_pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
                        DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
@@ -833,7 +834,6 @@
         location_(location),
         location_checksum_(location_checksum),
         mem_map_(mem_map),
-        dex_object_lock_("a dex_object_lock_"),
         dex_object_(NULL),
         header_(0),
         string_ids_(0),
@@ -892,8 +892,7 @@
   UniquePtr<MemMap> mem_map_;
 
   // A cached com.android.dex.Dex instance, possibly NULL. Use GetDexObject.
-  mutable Mutex dex_object_lock_;
-  mutable jobject dex_object_ GUARDED_BY(dex_object_lock_);
+  mutable jobject dex_object_;
 
   // Points to the header section.
   const Header* header_;
@@ -1105,9 +1104,11 @@
 class EncodedStaticFieldValueIterator {
  public:
   EncodedStaticFieldValueIterator(const DexFile& dex_file, DexCache* dex_cache,
-                                  ClassLinker* linker, const DexFile::ClassDef& class_def);
+                                  ClassLinker* linker, const DexFile::ClassDef& class_def)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void ReadValueToField(Field* field) const;
+  void ReadValueToField(Field* field) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool HasNext() { return pos_ < array_size_; }
 
diff --git a/src/exception_test.cc b/src/exception_test.cc
index 5c7e1a6..06ae7fb 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -19,7 +19,7 @@
 #include "dex_file.h"
 #include "gtest/gtest.h"
 #include "runtime.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "UniquePtr.h"
 
@@ -30,7 +30,8 @@
   virtual void SetUp() {
     CommonTest::SetUp();
 
-    SirtRef<ClassLoader> class_loader(LoadDex("ExceptionHandle"));
+    ScopedObjectAccess soa(Thread::Current());
+    SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(LoadDex("ExceptionHandle")));
     my_klass_ = class_linker_->FindClass("LExceptionHandle;", class_loader.get());
     ASSERT_TRUE(my_klass_ != NULL);
     class_linker_->EnsureInitialized(my_klass_, false, true);
@@ -116,7 +117,11 @@
 }
 
 TEST_F(ExceptionTest, StackTraceElement) {
+  Thread::Current()->TransitionFromSuspendedToRunnable();
   runtime_->Start();
+  Thread* thread = Thread::Current();
+  JNIEnv* env = thread->GetJniEnv();
+  ScopedObjectAccess soa(env);
 
   std::vector<uintptr_t> fake_stack;
   ASSERT_EQ(kStackAlignment, 16);
@@ -149,7 +154,6 @@
   fake_stack.push_back(0);
 
   // Set up thread to appear as if we called out of method_g_ at pc dex 3
-  Thread* thread = Thread::Current();
   thread->SetTopOfStack(&fake_stack[0], method_g_->ToNativePC(dex_pc) + 2);  // return pc
 #else
   // Create/push fake 20-byte shadow frame for method g
@@ -171,14 +175,12 @@
   thread->PushShadowFrame(reinterpret_cast<ShadowFrame*>(&fake_stack[0]));
 #endif
 
-  JNIEnv* env = thread->GetJniEnv();
-  ScopedJniThreadState ts(env);
-  jobject internal = thread->CreateInternalStackTrace(ts);
+  jobject internal = thread->CreateInternalStackTrace(soa);
   ASSERT_TRUE(internal != NULL);
   jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(env, internal);
   ASSERT_TRUE(ste_array != NULL);
   ObjectArray<StackTraceElement>* trace_array =
-      ts.Decode<ObjectArray<StackTraceElement>*>(ste_array);
+      soa.Decode<ObjectArray<StackTraceElement>*>(ste_array);
 
   ASSERT_TRUE(trace_array != NULL);
   ASSERT_TRUE(trace_array->Get(0) != NULL);
diff --git a/src/heap.cc b/src/heap.cc
index 626adf9..658755e 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -31,10 +31,8 @@
 #include "object.h"
 #include "object_utils.h"
 #include "os.h"
-#include "scoped_heap_lock.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock_releaser.h"
 #include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "stl_util.h"
 #include "thread_list.h"
@@ -136,26 +134,26 @@
 }
 
 Heap::Heap(size_t initial_size, size_t growth_limit, size_t capacity,
-           const std::string& original_image_file_name)
-    : lock_(NULL),
-      alloc_space_(NULL),
+           const std::string& original_image_file_name, bool concurrent_gc)
+    : alloc_space_(NULL),
       card_table_(NULL),
+      concurrent_gc_(concurrent_gc),
+      have_zygote_space_(false),
       card_marking_disabled_(false),
       is_gc_running_(false),
       concurrent_start_bytes_(std::numeric_limits<size_t>::max()),
       concurrent_start_size_(128 * KB),
       concurrent_min_free_(256 * KB),
-      try_running_gc_(false),
-      requesting_gc_(false),
       num_bytes_allocated_(0),
       num_objects_allocated_(0),
       last_trim_time_(0),
+      try_running_gc_(false),
+      requesting_gc_(false),
       reference_referent_offset_(0),
       reference_queue_offset_(0),
       reference_queueNext_offset_(0),
       reference_pendingNext_offset_(0),
       finalizer_reference_zombie_offset_(0),
-      have_zygote_space_(false),
       target_utilization_(0.5),
       verify_objects_(false) {
   if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
@@ -246,8 +244,9 @@
   // It's still too early to take a lock because there are no threads yet,
   // but we can create the heap lock now. We don't create it earlier to
   // make it clear that you can't use locks during heap initialization.
-  lock_.reset(new Mutex("Heap lock", kHeapLock));
-  condition_.reset(new ConditionVariable("Heap condition variable"));
+  statistics_lock_ = new Mutex("statistics lock");
+  gc_complete_lock_ =  new Mutex("GC complete lock");
+  gc_complete_cond_.reset(new ConditionVariable("GC complete condition variable"));
 
   if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
     LOG(INFO) << "Heap() exiting";
@@ -263,6 +262,7 @@
 };
 
 void Heap::AddSpace(Space* space) {
+  WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   DCHECK(space != NULL);
   DCHECK(space->GetLiveBitmap() != NULL);
   live_bitmap_->AddSpaceBitmap(space->GetLiveBitmap());
@@ -280,6 +280,9 @@
   // all daemon threads are suspended, and we also know that the threads list have been deleted, so
   // those threads can't resume. We're the only running thread, and we can do whatever we like...
   STLDeleteElements(&spaces_);
+  delete statistics_lock_;
+  delete gc_complete_lock_;
+
 }
 
 Space* Heap::FindSpaceFromObject(const Object* obj) const {
@@ -326,38 +329,39 @@
   int64_t total_bytes_free;
   size_t max_contiguous_allocation;
 
-  {
-    ScopedHeapLock heap_lock;
-    DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(Class)) ||
-           (c->IsVariableSize() || c->GetObjectSize() == byte_count) ||
-           strlen(ClassHelper(c).GetDescriptor()) == 0);
-    DCHECK_GE(byte_count, sizeof(Object));
-    Object* obj = AllocateLocked(byte_count);
-    if (obj != NULL) {
-      obj->SetClass(c);
-      if (Dbg::IsAllocTrackingEnabled()) {
-        Dbg::RecordAllocation(c, byte_count);
-      }
-
-      if (!is_gc_running_ && num_bytes_allocated_ >= concurrent_start_bytes_) {
-        // The SirtRef is necessary since the calls in RequestConcurrentGC are a safepoint.
-        SirtRef<Object> ref(obj);
-        RequestConcurrentGC();
-      }
-      VerifyObject(obj);
-
-      // Additional verification to ensure that we did not allocate into a zygote space.
-      DCHECK(!have_zygote_space_ || !FindSpaceFromObject(obj)->IsZygoteSpace());
-
-      return obj;
+  DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(Class)) ||
+         (c->IsVariableSize() || c->GetObjectSize() == byte_count) ||
+         strlen(ClassHelper(c).GetDescriptor()) == 0);
+  DCHECK_GE(byte_count, sizeof(Object));
+  Object* obj = Allocate(byte_count);
+  if (obj != NULL) {
+    obj->SetClass(c);
+    if (Dbg::IsAllocTrackingEnabled()) {
+      Dbg::RecordAllocation(c, byte_count);
     }
-    total_bytes_free = GetFreeMemory();
-    max_contiguous_allocation = 0;
-    // TODO: C++0x auto
-    for (Spaces::const_iterator cur = spaces_.begin(); cur != spaces_.end(); ++cur) {
-      if ((*cur)->IsAllocSpace()) {
-        (*cur)->AsAllocSpace()->Walk(MSpaceChunkCallback, &max_contiguous_allocation);
-      }
+    bool request_concurrent_gc;
+    {
+      MutexLock mu(*statistics_lock_);
+      request_concurrent_gc = num_bytes_allocated_ >= concurrent_start_bytes_;
+    }
+    if (request_concurrent_gc) {
+      // The SirtRef is necessary since the calls in RequestConcurrentGC are a safepoint.
+      SirtRef<Object> ref(obj);
+      RequestConcurrentGC();
+    }
+    VerifyObject(obj);
+
+    // Additional verification to ensure that we did not allocate into a zygote space.
+    DCHECK(!have_zygote_space_ || !FindSpaceFromObject(obj)->IsZygoteSpace());
+
+    return obj;
+  }
+  total_bytes_free = GetFreeMemory();
+  max_contiguous_allocation = 0;
+  // TODO: C++0x auto
+  for (Spaces::const_iterator cur = spaces_.begin(); cur != spaces_.end(); ++cur) {
+    if ((*cur)->IsAllocSpace()) {
+      (*cur)->AsAllocSpace()->Walk(MSpaceChunkCallback, &max_contiguous_allocation);
     }
   }
 
@@ -387,7 +391,7 @@
 }
 
 bool Heap::IsLiveObjectLocked(const Object* obj) {
-  lock_->AssertHeld();
+  GlobalSynchronization::heap_bitmap_lock_->AssertReaderHeld();
   return IsHeapAddress(obj) && GetLiveBitmap()->Test(obj);
 }
 
@@ -399,7 +403,7 @@
     return;
   }
   {
-    ScopedHeapLock heap_lock;
+    ReaderMutexLock mu(GlobalSynchronization::heap_bitmap_lock_);
     Heap::VerifyObjectLocked(obj);
   }
 }
@@ -413,7 +417,7 @@
 }
 
 void Heap::VerifyObjectLocked(const Object* obj) {
-  lock_->AssertHeld();
+  GlobalSynchronization::heap_bitmap_lock_->AssertReaderHeld();
   if (!IsAligned<kObjectAlignment>(obj)) {
     LOG(FATAL) << "Object isn't aligned: " << obj;
   } else if (!GetLiveBitmap()->Test(obj)) {
@@ -455,35 +459,35 @@
 }
 
 void Heap::VerifyHeap() {
-  ScopedHeapLock heap_lock;
+  ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   GetLiveBitmap()->Walk(Heap::VerificationCallback, this);
 }
 
-void Heap::RecordAllocationLocked(AllocSpace* space, const Object* obj) {
-#ifndef NDEBUG
-  if (Runtime::Current()->IsStarted()) {
-    lock_->AssertHeld();
-  }
-#endif
-  size_t size = space->AllocationSize(obj);
-  DCHECK_GT(size, 0u);
-  num_bytes_allocated_ += size;
-  num_objects_allocated_ += 1;
+void Heap::RecordAllocation(AllocSpace* space, const Object* obj) {
+  {
+    MutexLock mu(*statistics_lock_);
+    size_t size = space->AllocationSize(obj);
+    DCHECK_GT(size, 0u);
+    num_bytes_allocated_ += size;
+    num_objects_allocated_ += 1;
 
-  if (Runtime::Current()->HasStatsEnabled()) {
-    RuntimeStats* global_stats = Runtime::Current()->GetStats();
-    RuntimeStats* thread_stats = Thread::Current()->GetStats();
-    ++global_stats->allocated_objects;
-    ++thread_stats->allocated_objects;
-    global_stats->allocated_bytes += size;
-    thread_stats->allocated_bytes += size;
+    if (Runtime::Current()->HasStatsEnabled()) {
+      RuntimeStats* global_stats = Runtime::Current()->GetStats();
+      RuntimeStats* thread_stats = Thread::Current()->GetStats();
+      ++global_stats->allocated_objects;
+      ++thread_stats->allocated_objects;
+      global_stats->allocated_bytes += size;
+      thread_stats->allocated_bytes += size;
+    }
   }
-
-  live_bitmap_->Set(obj);
+  {
+    WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+    live_bitmap_->Set(obj);
+  }
 }
 
-void Heap::RecordFreeLocked(size_t freed_objects, size_t freed_bytes) {
-  lock_->AssertHeld();
+void Heap::RecordFree(size_t freed_objects, size_t freed_bytes) {
+  MutexLock mu(*statistics_lock_);
 
   if (freed_objects < num_objects_allocated_) {
     num_objects_allocated_ -= freed_objects;
@@ -506,32 +510,39 @@
   }
 }
 
-Object* Heap::AllocateLocked(size_t size) {
-  lock_->AssertHeld();
-
-  // Try the default alloc space first.
-  Object* obj = AllocateLocked(alloc_space_, size);
+Object* Heap::Allocate(size_t size) {
+  Object* obj = Allocate(alloc_space_, size);
   if (obj != NULL) {
-    RecordAllocationLocked(alloc_space_, obj);
+    RecordAllocation(alloc_space_, obj);
     return obj;
   }
 
   return NULL;
 }
 
-Object* Heap::AllocateLocked(AllocSpace* space, size_t alloc_size) {
-  lock_->AssertHeld();
-
+Object* Heap::Allocate(AllocSpace* space, size_t alloc_size) {
+  Thread* self = Thread::Current();
   // Since allocation can cause a GC which will need to SuspendAll, make sure all allocations are
   // done in the runnable state where suspension is expected.
-  DCHECK_EQ(Thread::Current()->GetState(), kRunnable);
-  Thread::Current()->AssertThreadSuspensionIsAllowable();
+#ifndef NDEBUG
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(self->GetState(), kRunnable);
+  }
+  self->AssertThreadSuspensionIsAllowable();
+#endif
 
   // Fail impossible allocations
   if (alloc_size > space->Capacity()) {
     // On failure collect soft references
     WaitForConcurrentGcToComplete();
-    CollectGarbageInternal(false, false, true);
+    if (Runtime::Current()->HasStatsEnabled()) {
+      ++Runtime::Current()->GetStats()->gc_for_alloc_count;
+      ++Thread::Current()->GetStats()->gc_for_alloc_count;
+    }
+    self->TransitionFromRunnableToSuspended(kWaitingPerformingGc);
+    CollectGarbageInternal(false, true);
+    self->TransitionFromSuspendedToRunnable();
     return NULL;
   }
 
@@ -540,43 +551,40 @@
     return ptr;
   }
 
-  // The allocation failed.  If the GC is running, block until it completes and retry.
-  if (is_gc_running_) {
-    // The GC is concurrently tracing the heap.  Release the heap lock, wait for the GC to
-    // complete, and retrying allocating.
-    WaitForConcurrentGcToComplete();
-    ptr = space->AllocWithoutGrowth(alloc_size);
-    if (ptr != NULL) {
-      return ptr;
+  // The allocation failed.  If the GC is running, block until it completes else request a
+  // foreground partial collection.
+  if (!WaitForConcurrentGcToComplete()) {
+    // No concurrent GC so perform a foreground collection.
+    if (Runtime::Current()->HasStatsEnabled()) {
+      ++Runtime::Current()->GetStats()->gc_for_alloc_count;
+      ++Thread::Current()->GetStats()->gc_for_alloc_count;
     }
+    self->TransitionFromRunnableToSuspended(kWaitingPerformingGc);
+    CollectGarbageInternal(have_zygote_space_, false);
+    self->TransitionFromSuspendedToRunnable();
   }
 
-  // Another failure.  Our thread was starved or there may be too many
-  // live objects.  Try a foreground GC.  This will have no effect if
-  // the concurrent GC is already running.
-  if (Runtime::Current()->HasStatsEnabled()) {
-    ++Runtime::Current()->GetStats()->gc_for_alloc_count;
-    ++Thread::Current()->GetStats()->gc_for_alloc_count;
-  }
-
-  if (have_zygote_space_) {
-    // We don't need a WaitForConcurrentGcToComplete here since we checked is_gc_running_ earlier
-    // and we are in a heap lock. Try partial GC first.
-    CollectGarbageInternal(true, false, false);
-    ptr = space->AllocWithoutGrowth(alloc_size);
-    if (ptr != NULL) {
-      return ptr;
-    }
-  }
-
-  // Partial GC didn't free enough memory, try a full GC.
-  CollectGarbageInternal(false, false, false);
   ptr = space->AllocWithoutGrowth(alloc_size);
   if (ptr != NULL) {
     return ptr;
   }
 
-  // Even that didn't work;  this is an exceptional state.
+  if (!have_zygote_space_) {
+    // Partial GC didn't free enough memory, try a full GC.
+    if (Runtime::Current()->HasStatsEnabled()) {
+      ++Runtime::Current()->GetStats()->gc_for_alloc_count;
+      ++Thread::Current()->GetStats()->gc_for_alloc_count;
+    }
+    self->TransitionFromRunnableToSuspended(kWaitingPerformingGc);
+    CollectGarbageInternal(false, false);
+    self->TransitionFromSuspendedToRunnable();
+    ptr = space->AllocWithoutGrowth(alloc_size);
+    if (ptr != NULL) {
+      return ptr;
+    }
+  }
+
+  // Allocations have failed after GCs;  this is an exceptional state.
   // Try harder, growing the heap if necessary.
   ptr = space->AllocWithGrowth(alloc_size);
   if (ptr != NULL) {
@@ -595,13 +603,20 @@
 
   // OLD-TODO: wait for the finalizers from the previous GC to finish
   VLOG(gc) << "Forcing collection of SoftReferences for " << PrettySize(alloc_size) << " allocation";
+
+  if (Runtime::Current()->HasStatsEnabled()) {
+    ++Runtime::Current()->GetStats()->gc_for_alloc_count;
+    ++Thread::Current()->GetStats()->gc_for_alloc_count;
+  }
   // We don't need a WaitForConcurrentGcToComplete here either.
-  CollectGarbageInternal(false, false, true);
+  self->TransitionFromRunnableToSuspended(kWaitingPerformingGc);
+  CollectGarbageInternal(false, true);
+  self->TransitionFromSuspendedToRunnable();
   ptr = space->AllocWithGrowth(alloc_size);
   if (ptr != NULL) {
     return ptr;
   }
-
+  // Allocation failed.
   return NULL;
 }
 
@@ -621,12 +636,14 @@
 }
 
 int64_t Heap::GetFreeMemory() {
+  MutexLock mu(*statistics_lock_);
   return GetMaxMemory() - num_bytes_allocated_;
 }
 
 class InstanceCounter {
  public:
   InstanceCounter(Class* c, bool count_assignable)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : class_(c), count_assignable_(count_assignable), count_(0) {
   }
 
@@ -634,12 +651,13 @@
     return count_;
   }
 
-  static void Callback(Object* o, void* arg) {
+  static void Callback(Object* o, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     reinterpret_cast<InstanceCounter*>(arg)->VisitInstance(o);
   }
 
  private:
-  void VisitInstance(Object* o) {
+  void VisitInstance(Object* o) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* instance_class = o->GetClass();
     if (count_assignable_) {
       if (instance_class == class_) {
@@ -658,23 +676,24 @@
 };
 
 int64_t Heap::CountInstances(Class* c, bool count_assignable) {
-  ScopedHeapLock heap_lock;
+  ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   InstanceCounter counter(c, count_assignable);
   GetLiveBitmap()->Walk(InstanceCounter::Callback, &counter);
   return counter.GetCount();
 }
 
 void Heap::CollectGarbage(bool clear_soft_references) {
-  ScopedHeapLock heap_lock;
   // If we just waited for a GC to complete then we do not need to do another
   // GC unless we clear soft references.
   if (!WaitForConcurrentGcToComplete() || clear_soft_references) {
-    CollectGarbageInternal(have_zygote_space_, true, clear_soft_references);
+    ScopedThreadStateChange tsc(Thread::Current(), kWaitingPerformingGc);
+    CollectGarbageInternal(have_zygote_space_, clear_soft_references);
   }
 }
 
 void Heap::PreZygoteFork() {
-  ScopedHeapLock heap_lock;
+  static Mutex zygote_creation_lock_("zygote creation lock", kZygoteCreationLock);
+  MutexLock mu(zygote_creation_lock_);
 
   // Try to see if we have any Zygote spaces.
   if (have_zygote_space_) {
@@ -702,20 +721,59 @@
   }
 }
 
-void Heap::CollectGarbageInternal(bool partial_gc, bool concurrent, bool clear_soft_references) {
-  lock_->AssertHeld();
+void Heap::CollectGarbageInternal(bool partial_gc, bool clear_soft_references) {
+  GlobalSynchronization::mutator_lock_->AssertNotHeld();
+#ifndef NDEBUG
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(Thread::Current()->GetState(), kWaitingPerformingGc);
+  }
+#endif
 
-  CHECK(!is_gc_running_) << "Attempted recursive GC";
-  is_gc_running_ = true;
+  // Ensure there is only one GC at a time.
+  bool start_collect = false;
+  while (!start_collect) {
+    {
+      MutexLock mu(*gc_complete_lock_);
+      if (!is_gc_running_) {
+        is_gc_running_ = true;
+        start_collect = true;
+      }
+    }
+    if (!start_collect) {
+      WaitForConcurrentGcToComplete();
+      // TODO: if another thread beat this one to do the GC, perhaps we should just return here?
+      //       Not doing at the moment to ensure soft references are cleared.
+    }
+  }
+  gc_complete_lock_->AssertNotHeld();
+  if (concurrent_gc_) {
+    CollectGarbageConcurrentMarkSweepPlan(partial_gc, clear_soft_references);
+  } else {
+    CollectGarbageMarkSweepPlan(partial_gc, clear_soft_references);
+  }
+  gc_complete_lock_->AssertNotHeld();
+  MutexLock mu(*gc_complete_lock_);
+  is_gc_running_ = false;
+  // Wake anyone who may have been waiting for the GC to complete.
+  gc_complete_cond_->Broadcast();
+}
 
+void Heap::CollectGarbageMarkSweepPlan(bool partial_gc, bool clear_soft_references) {
   TimingLogger timings("CollectGarbageInternal");
-  uint64_t t0 = NanoTime(), root_end = 0, dirty_begin = 0, dirty_end = 0;
+  uint64_t t0 = NanoTime(), dirty_end = 0;
 
+  // Suspend all threads are get exclusive access to the heap.
   ThreadList* thread_list = Runtime::Current()->GetThreadList();
   thread_list->SuspendAll();
   timings.AddSplit("SuspendAll");
+  GlobalSynchronization::mutator_lock_->AssertExclusiveHeld();
 
-  size_t initial_size = num_bytes_allocated_;
+  size_t initial_size;
+  {
+    MutexLock mu(*statistics_lock_);
+    initial_size = num_bytes_allocated_;
+  }
   Object* cleared_references = NULL;
   {
     MarkSweep mark_sweep(mark_stack_.get());
@@ -735,8 +793,6 @@
         mod_union_table_->ClearCards(*it);
       } else if (space->GetGcRetentionPolicy() == GCRP_FULL_COLLECT) {
         zygote_mod_union_table_->ClearCards(space);
-      } else if (concurrent) {
-        card_table_->ClearSpaceCards(space);
       }
     }
     timings.AddSplit("ClearCards");
@@ -746,6 +802,7 @@
     zygote_mod_union_table_->Verify();
 #endif
 
+    WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
     if (partial_gc) {
       // Copy the mark bits over from the live bits, do this as early as possible or else we can
       // accidentally un-mark roots.
@@ -760,15 +817,6 @@
     // Roots are marked on the bitmap and the mark_stack is empty.
     DCHECK(mark_sweep.IsMarkStackEmpty());
 
-    if (concurrent) {
-      // We need to resume before unlocking or else a thread waiting for the
-      // heap lock would re-suspend since we have not yet called ResumeAll.
-      thread_list->ResumeAll();
-      Unlock();
-      root_end = NanoTime();
-      timings.AddSplit("RootEnd");
-    }
-
     // Update zygote mod union table.
     if (partial_gc) {
       zygote_mod_union_table_->Update();
@@ -790,21 +838,6 @@
     mark_sweep.RecursiveMark(partial_gc);
     timings.AddSplit(partial_gc ? "PartialMark" : "RecursiveMark");
 
-    if (concurrent) {
-      dirty_begin = NanoTime();
-      Lock();
-      thread_list->SuspendAll();
-      timings.AddSplit("ReSuspend");
-
-      // Re-mark root set.
-      mark_sweep.ReMarkRoots();
-      timings.AddSplit("ReMarkRoots");
-
-      // Scan dirty objects, this is only required if we are not doing concurrent GC.
-      mark_sweep.RecursiveMarkDirtyObjects();
-      timings.AddSplit("RecursiveMarkDirtyObjects");
-    }
-
     mark_sweep.ProcessReferences(clear_soft_references);
     timings.AddSplit("ProcessReferences");
 
@@ -826,31 +859,17 @@
     mark_sweep.VerifyImageRoots();
     timings.AddSplit("VerifyImageRoots");
 
-    if (concurrent) {
-      thread_list->ResumeAll();
-      dirty_end = NanoTime();
-      Unlock();
-    }
-
     mark_sweep.Sweep(partial_gc);
     timings.AddSplit("Sweep");
 
     cleared_references = mark_sweep.GetClearedReferences();
   }
 
-  if (concurrent) {
-    // Relock since we unlocked earlier.
-    // TODO: We probably don't need to have the heap locked for all remainder of the function, except for GrowForUtilization.
-    Lock();
-  }
-
   GrowForUtilization();
   timings.AddSplit("GrowForUtilization");
 
-  if (!concurrent) {
-    thread_list->ResumeAll();
-    dirty_end = NanoTime();
-  }
+  thread_list->ResumeAll();
+  dirty_end = NanoTime();
 
   EnqueueClearedReferences(&cleared_references);
   RequestHeapTrim();
@@ -859,6 +878,7 @@
   if (VLOG_IS_ON(gc)) {
     uint64_t t1 = NanoTime();
 
+    MutexLock mu(*statistics_lock_);
     // TODO: somehow make the specific GC implementation (here MarkSweep) responsible for logging.
     // Reason: For CMS sometimes initial_size < num_bytes_allocated_ results in overflow (3GB freed message).
     size_t bytes_freed = initial_size - num_bytes_allocated_;
@@ -866,61 +886,241 @@
     duration_ns -= duration_ns % 1000;
 
     // If the GC was slow, then print timings in the log.
-    if (concurrent) {
-      uint64_t pause_roots = (root_end - t0) / 1000 * 1000;
-      uint64_t pause_dirty = (dirty_end - dirty_begin) / 1000 * 1000;
-      if (pause_roots > MsToNs(5) || pause_dirty > MsToNs(5)) {
-        LOG(INFO) << (partial_gc ? "Partial " : "")
-                  << "GC freed " << PrettySize(bytes_freed) << ", " << GetPercentFree() << "% free, "
-                  << PrettySize(num_bytes_allocated_) << "/" << PrettySize(GetTotalMemory()) << ", "
-                  << "paused " << PrettyDuration(pause_roots) << "+" << PrettyDuration(pause_dirty)
-                  << ", total " << PrettyDuration(duration_ns);
-      }
-    } else {
-      if (duration_ns > MsToNs(50)) {
-        uint64_t markSweepTime = (dirty_end - t0) / 1000 * 1000;
-        LOG(INFO) << (partial_gc ? "Partial " : "")
-                  << "GC freed " << PrettySize(bytes_freed) << ", " << GetPercentFree() << "% free, "
-                  << PrettySize(num_bytes_allocated_) << "/" << PrettySize(GetTotalMemory()) << ", "
-                  << "paused " << PrettyDuration(markSweepTime)
-                  << ", total " << PrettyDuration(duration_ns);
-      }
+    if (duration_ns > MsToNs(50)) {
+      uint64_t markSweepTime = (dirty_end - t0) / 1000 * 1000;
+      LOG(INFO) << (partial_gc ? "Partial " : "")
+                      << "GC freed " << PrettySize(bytes_freed) << ", " << GetPercentFree() << "% free, "
+                      << PrettySize(num_bytes_allocated_) << "/" << PrettySize(GetTotalMemory()) << ", "
+                      << "paused " << PrettyDuration(markSweepTime)
+                      << ", total " << PrettyDuration(duration_ns);
     }
   }
   Dbg::GcDidFinish();
   if (VLOG_IS_ON(heap)) {
     timings.Dump();
   }
+}
 
-  is_gc_running_ = false;
+void Heap::CollectGarbageConcurrentMarkSweepPlan(bool partial_gc, bool clear_soft_references) {
+  TimingLogger timings("CollectGarbageInternal");
+  uint64_t t0 = NanoTime(), root_end = 0, dirty_begin = 0, dirty_end = 0;
 
-  // Wake anyone who may have been waiting for the GC to complete.
-  condition_->Broadcast();
+  // Suspend all threads are get exclusive access to the heap.
+  ThreadList* thread_list = Runtime::Current()->GetThreadList();
+  thread_list->SuspendAll();
+  timings.AddSplit("SuspendAll");
+  GlobalSynchronization::mutator_lock_->AssertExclusiveHeld();
+
+  size_t initial_size;
+  {
+    MutexLock mu(*statistics_lock_);
+    initial_size = num_bytes_allocated_;
+  }
+  Object* cleared_references = NULL;
+  {
+    MarkSweep mark_sweep(mark_stack_.get());
+    timings.AddSplit("ctor");
+
+    mark_sweep.Init();
+    timings.AddSplit("Init");
+
+    // Make sure that the tables have the correct pointer for the mark sweep.
+    mod_union_table_->Init(&mark_sweep);
+    zygote_mod_union_table_->Init(&mark_sweep);
+
+    // Clear image space cards and keep track of cards we cleared in the mod-union table.
+    for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) {
+      Space* space = *it;
+      if (space->IsImageSpace()) {
+        mod_union_table_->ClearCards(*it);
+      } else if (space->GetGcRetentionPolicy() == GCRP_FULL_COLLECT) {
+        zygote_mod_union_table_->ClearCards(space);
+      } else {
+        card_table_->ClearSpaceCards(space);
+      }
+    }
+    timings.AddSplit("ClearCards");
+
+#if VERIFY_MOD_UNION
+    mod_union_table_->Verify();
+    zygote_mod_union_table_->Verify();
+#endif
+
+    if (partial_gc) {
+      // Copy the mark bits over from the live bits, do this as early as possible or else we can
+      // accidentally un-mark roots.
+      // Needed for scanning dirty objects.
+      mark_sweep.CopyMarkBits();
+      timings.AddSplit("CopyMarkBits");
+    }
+
+    {
+      WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      mark_sweep.MarkRoots();
+      timings.AddSplit("MarkRoots");
+    }
+
+    // Roots are marked on the bitmap and the mark_stack is empty.
+    DCHECK(mark_sweep.IsMarkStackEmpty());
+
+    // Allow mutators to go again, acquire share on mutator_lock_ to continue.
+    thread_list->ResumeAll();
+    {
+      ReaderMutexLock reader_lock(*GlobalSynchronization::mutator_lock_);
+      root_end = NanoTime();
+      timings.AddSplit("RootEnd");
+
+      {
+        ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+        // Update zygote mod union table.
+        if (partial_gc) {
+          zygote_mod_union_table_->Update();
+          timings.AddSplit("UpdateZygoteModUnionTable");
+
+          zygote_mod_union_table_->MarkReferences();
+          timings.AddSplit("ZygoteMarkReferences");
+        }
+
+        // Processes the cards we cleared earlier and adds their objects into the mod-union table.
+        mod_union_table_->Update();
+        timings.AddSplit("UpdateModUnionTable");
+      }
+      {
+        WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+        // Scans all objects in the mod-union table.
+        mod_union_table_->MarkReferences();
+        timings.AddSplit("MarkImageToAllocSpaceReferences");
+
+        // Recursively mark all the non-image bits set in the mark bitmap.
+        mark_sweep.RecursiveMark(partial_gc);
+        timings.AddSplit(partial_gc ? "PartialMark" : "RecursiveMark");
+      }
+    }
+    // Release share on mutator_lock_ and then get exclusive access.
+    dirty_begin = NanoTime();
+    thread_list->SuspendAll();
+    timings.AddSplit("ReSuspend");
+    GlobalSynchronization::mutator_lock_->AssertExclusiveHeld();
+
+    {
+      WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      // Re-mark root set.
+      mark_sweep.ReMarkRoots();
+      timings.AddSplit("ReMarkRoots");
+
+      // Scan dirty objects, this is only required if we are not doing concurrent GC.
+      mark_sweep.RecursiveMarkDirtyObjects();
+      timings.AddSplit("RecursiveMarkDirtyObjects");
+    }
+    {
+      ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      mark_sweep.ProcessReferences(clear_soft_references);
+      timings.AddSplit("ProcessReferences");
+    }
+    // Swap the live and mark bitmaps for each alloc space. This is needed since sweep re-swaps
+    // these bitmaps. Doing this enables us to sweep with the heap unlocked since new allocations
+    // set the live bit, but since we have the bitmaps reversed at this point, this sets the mark
+    // bit instead, resulting in no new allocated objects being incorrectly freed by sweep.
+    {
+      WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      for (Spaces::iterator it = spaces_.begin(); it != spaces_.end(); ++it) {
+        Space* space = *it;
+        // We never allocate into zygote spaces.
+        if (space->GetGcRetentionPolicy() == GCRP_ALWAYS_COLLECT) {
+          live_bitmap_->ReplaceBitmap(space->GetLiveBitmap(), space->GetMarkBitmap());
+          mark_bitmap_->ReplaceBitmap(space->GetMarkBitmap(), space->GetLiveBitmap());
+          space->AsAllocSpace()->SwapBitmaps();
+        }
+      }
+    }
+
+    if (kIsDebugBuild) {
+      // Verify that we only reach marked objects from the image space.
+      ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      mark_sweep.VerifyImageRoots();
+      timings.AddSplit("VerifyImageRoots");
+    }
+    thread_list->ResumeAll();
+    dirty_end = NanoTime();
+    GlobalSynchronization::mutator_lock_->AssertNotHeld();
+
+    {
+      // TODO: this lock shouldn't be necessary (it's why we did the bitmap flip above).
+      WriterMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      mark_sweep.Sweep(partial_gc);
+      timings.AddSplit("Sweep");
+    }
+
+    cleared_references = mark_sweep.GetClearedReferences();
+  }
+
+  GrowForUtilization();
+  timings.AddSplit("GrowForUtilization");
+
+  EnqueueClearedReferences(&cleared_references);
+  RequestHeapTrim();
+  timings.AddSplit("Finish");
+
+  if (VLOG_IS_ON(gc)) {
+    uint64_t t1 = NanoTime();
+
+    MutexLock mu(*statistics_lock_);
+    // TODO: somehow make the specific GC implementation (here MarkSweep) responsible for logging.
+    // Reason: For CMS sometimes initial_size < num_bytes_allocated_ results in overflow (3GB freed message).
+    size_t bytes_freed = initial_size - num_bytes_allocated_;
+    uint64_t duration_ns = t1 - t0;
+    duration_ns -= duration_ns % 1000;
+
+    // If the GC was slow, then print timings in the log.
+    uint64_t pause_roots = (root_end - t0) / 1000 * 1000;
+    uint64_t pause_dirty = (dirty_end - dirty_begin) / 1000 * 1000;
+    if (pause_roots > MsToNs(5) || pause_dirty > MsToNs(5)) {
+      LOG(INFO) << (partial_gc ? "Partial " : "")
+                      << "GC freed " << PrettySize(bytes_freed) << ", " << GetPercentFree() << "% free, "
+                      << PrettySize(num_bytes_allocated_) << "/" << PrettySize(GetTotalMemory()) << ", "
+                      << "paused " << PrettyDuration(pause_roots) << "+" << PrettyDuration(pause_dirty)
+                      << ", total " << PrettyDuration(duration_ns);
+    }
+  }
+  Dbg::GcDidFinish();
+  if (VLOG_IS_ON(heap)) {
+    timings.Dump();
+  }
 }
 
 bool Heap::WaitForConcurrentGcToComplete() {
-  lock_->AssertHeld();
-
-  // Busy wait for GC to finish
-  if (is_gc_running_) {
-    uint64_t wait_start = NanoTime();
-
-    do {
-      ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
-      ScopedThreadListLockReleaser list_lock_releaser;
-      condition_->Wait(*lock_);
-    } while (is_gc_running_);
-    uint64_t wait_time = NanoTime() - wait_start;
-    if (wait_time > MsToNs(5)) {
-      LOG(INFO) << "WaitForConcurrentGcToComplete blocked for " << PrettyDuration(wait_time);
+  if (concurrent_gc_) {
+    bool do_wait = false;
+    uint64_t wait_start;
+    {
+      // Check if GC is running holding gc_complete_lock_.
+      MutexLock mu(*gc_complete_lock_);
+      if (is_gc_running_) {
+        wait_start = NanoTime();
+        do_wait = true;
+      }
     }
-    DCHECK(!is_gc_running_);
-    return true;
+    if (do_wait) {
+      // We must wait, change thread state then sleep on gc_complete_cond_;
+      ScopedThreadStateChange tsc(Thread::Current(), kWaitingForGcToComplete);
+      {
+        MutexLock mu(*gc_complete_lock_);
+        while (is_gc_running_) {
+          gc_complete_cond_->Wait(*gc_complete_lock_);
+        }
+      }
+      uint64_t wait_time = NanoTime() - wait_start;
+      if (wait_time > MsToNs(5)) {
+        LOG(INFO) << "WaitForConcurrentGcToComplete blocked for " << PrettyDuration(wait_time);
+      }
+      return true;
+    }
   }
   return false;
 }
 
 void Heap::DumpForSigQuit(std::ostream& os) {
+  MutexLock mu(*statistics_lock_);
   os << "Heap: " << GetPercentFree() << "% free, "
      << PrettySize(num_bytes_allocated_) << "/" << PrettySize(GetTotalMemory())
      << "; " << num_objects_allocated_ << " objects\n";
@@ -950,56 +1150,42 @@
 static const size_t kHeapMinFree = kHeapIdealFree / 4;
 
 void Heap::GrowForUtilization() {
-  lock_->AssertHeld();
+  size_t target_size;
+  bool use_footprint_limit = false;
+  {
+    MutexLock mu(*statistics_lock_);
+    // We know what our utilization is at this moment.
+    // This doesn't actually resize any memory. It just lets the heap grow more when necessary.
+    target_size = num_bytes_allocated_ / Heap::GetTargetHeapUtilization();
 
-  // We know what our utilization is at this moment.
-  // This doesn't actually resize any memory. It just lets the heap grow more
-  // when necessary.
-  size_t target_size(num_bytes_allocated_ / Heap::GetTargetHeapUtilization());
+    if (target_size > num_bytes_allocated_ + kHeapIdealFree) {
+      target_size = num_bytes_allocated_ + kHeapIdealFree;
+    } else if (target_size < num_bytes_allocated_ + kHeapMinFree) {
+      target_size = num_bytes_allocated_ + kHeapMinFree;
+    }
 
-  if (target_size > num_bytes_allocated_ + kHeapIdealFree) {
-    target_size = num_bytes_allocated_ + kHeapIdealFree;
-  } else if (target_size < num_bytes_allocated_ + kHeapMinFree) {
-    target_size = num_bytes_allocated_ + kHeapMinFree;
+    // Calculate when to perform the next ConcurrentGC.
+    if (GetTotalMemory() - num_bytes_allocated_ < concurrent_min_free_) {
+      // Not enough free memory to perform concurrent GC.
+      concurrent_start_bytes_ = std::numeric_limits<size_t>::max();
+    } else {
+      // Compute below to avoid holding both the statistics and the alloc space lock
+      use_footprint_limit = true;
+    }
   }
-
-  // Calculate when to perform the next ConcurrentGC.
-  if (GetTotalMemory() - num_bytes_allocated_ < concurrent_min_free_) {
-    // Not enough free memory to perform concurrent GC.
-    concurrent_start_bytes_ = std::numeric_limits<size_t>::max();
-  } else {
-    concurrent_start_bytes_ = alloc_space_->GetFootprintLimit() - concurrent_start_size_;
+  if (use_footprint_limit) {
+    size_t foot_print_limit = alloc_space_->GetFootprintLimit();
+    MutexLock mu(*statistics_lock_);
+    concurrent_start_bytes_ = foot_print_limit - concurrent_start_size_;
   }
-
   SetIdealFootprint(target_size);
 }
 
 void Heap::ClearGrowthLimit() {
-  ScopedHeapLock heap_lock;
   WaitForConcurrentGcToComplete();
   alloc_space_->ClearGrowthLimit();
 }
 
-pid_t Heap::GetLockOwner() {
-  return lock_->GetOwner();
-}
-
-void Heap::Lock() {
-  // Grab the lock, but put ourselves into kVmWait if it looks
-  // like we're going to have to wait on the mutex. This prevents
-  // deadlock if another thread is calling CollectGarbageInternal,
-  // since they will have the heap lock and be waiting for mutators to
-  // suspend.
-  if (!lock_->TryLock()) {
-    ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
-    lock_->Lock();
-  }
-}
-
-void Heap::Unlock() {
-  lock_->Unlock();
-}
-
 void Heap::SetReferenceOffsets(MemberOffset reference_referent_offset,
     MemberOffset reference_queue_offset,
     MemberOffset reference_queueNext_offset,
@@ -1076,19 +1262,41 @@
 }
 
 void Heap::AddFinalizerReference(Thread* self, Object* object) {
-  ScopedJniThreadState ts(self);
+  ScopedObjectAccess soa(self);
   JValue args[1];
   args[0].SetL(object);
-  ts.DecodeMethod(WellKnownClasses::java_lang_ref_FinalizerReference_add)->Invoke(self, NULL, args, NULL);
+  soa.DecodeMethod(WellKnownClasses::java_lang_ref_FinalizerReference_add)->Invoke(self,
+                                                                                  NULL, args, NULL);
+}
+
+size_t Heap::GetBytesAllocated() const {
+  MutexLock mu(*statistics_lock_);
+  return num_bytes_allocated_;
+}
+
+size_t Heap::GetObjectsAllocated() const {
+  MutexLock mu(*statistics_lock_);
+  return num_objects_allocated_;
+}
+
+size_t Heap::GetConcurrentStartSize() const {
+  MutexLock mu(*statistics_lock_);
+  return concurrent_start_size_;
+}
+
+size_t Heap::GetConcurrentMinFree() const {
+  MutexLock mu(*statistics_lock_);
+  return concurrent_min_free_;
 }
 
 void Heap::EnqueueClearedReferences(Object** cleared) {
   DCHECK(cleared != NULL);
   if (*cleared != NULL) {
-    ScopedJniThreadState ts(Thread::Current());
+    ScopedObjectAccess soa(Thread::Current());
     JValue args[1];
     args[0].SetL(*cleared);
-    ts.DecodeMethod(WellKnownClasses::java_lang_ref_ReferenceQueue_add)->Invoke(ts.Self(), NULL, args, NULL);
+    soa.DecodeMethod(WellKnownClasses::java_lang_ref_ReferenceQueue_add)->Invoke(soa.Self(),
+                                                                                 NULL, args, NULL);
     *cleared = NULL;
   }
 }
@@ -1106,29 +1314,27 @@
   JNIEnv* env = Thread::Current()->GetJniEnv();
   DCHECK(WellKnownClasses::java_lang_Daemons != NULL);
   DCHECK(WellKnownClasses::java_lang_Daemons_requestGC != NULL);
-  env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, WellKnownClasses::java_lang_Daemons_requestGC);
+  env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
+                            WellKnownClasses::java_lang_Daemons_requestGC);
   CHECK(!env->ExceptionCheck());
   requesting_gc_ = false;
 }
 
 void Heap::ConcurrentGC() {
-  if (Runtime::Current()->IsShuttingDown()) {
+  if (Runtime::Current()->IsShuttingDown() || !concurrent_gc_) {
     return;
   }
-  ScopedHeapLock heap_lock;
-  // We shouldn't need a WaitForConcurrentGcToComplete here since only
-  // concurrent GC resumes threads before the GC is completed and this function
-  // is only called within the GC daemon thread.
-  CHECK(!is_gc_running_);
-  // Current thread needs to be runnable or else we can't suspend all threads.
-  ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+  // TODO: We shouldn't need a WaitForConcurrentGcToComplete here since only
+  //       concurrent GC resumes threads before the GC is completed and this function
+  //       is only called within the GC daemon thread.
   if (!WaitForConcurrentGcToComplete()) {
-    CollectGarbageInternal(have_zygote_space_, true, false);
+    // Start a concurrent GC as one wasn't in progress
+    ScopedThreadStateChange tsc(Thread::Current(), kWaitingPerformingGc);
+    CollectGarbageInternal(have_zygote_space_, false);
   }
 }
 
 void Heap::Trim(AllocSpace* alloc_space) {
-  lock_->AssertHeld();
   WaitForConcurrentGcToComplete();
   alloc_space->Trim();
 }
@@ -1140,12 +1346,15 @@
   // to utilization (which is probably inversely proportional to how much benefit we can expect).
   // We could try mincore(2) but that's only a measure of how many pages we haven't given away,
   // not how much use we're making of those pages.
-  float utilization = static_cast<float>(num_bytes_allocated_) / alloc_space_->Size();
   uint64_t ms_time = NsToMs(NanoTime());
-  if (utilization > 0.75f || ms_time - last_trim_time_ < 2 * 1000) {
-    // Don't bother trimming the heap if it's more than 75% utilized, or if a
-    // heap trim occurred in the last two seconds.
-    return;
+  {
+    MutexLock mu(*statistics_lock_);
+    float utilization = static_cast<float>(num_bytes_allocated_) / alloc_space_->Size();
+    if ((utilization > 0.75f) || ((ms_time - last_trim_time_) < 2 * 1000)) {
+      // Don't bother trimming the heap if it's more than 75% utilized, or if a
+      // heap trim occurred in the last two seconds.
+      return;
+    }
   }
   if (!Runtime::Current()->IsFinishedStarting() || Runtime::Current()->IsShuttingDown()) {
     // Heap trimming isn't supported without a Java runtime or Daemons (such as at dex2oat time)
@@ -1156,7 +1365,8 @@
   JNIEnv* env = Thread::Current()->GetJniEnv();
   DCHECK(WellKnownClasses::java_lang_Daemons != NULL);
   DCHECK(WellKnownClasses::java_lang_Daemons_requestHeapTrim != NULL);
-  env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, WellKnownClasses::java_lang_Daemons_requestHeapTrim);
+  env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
+                            WellKnownClasses::java_lang_Daemons_requestHeapTrim);
   CHECK(!env->ExceptionCheck());
 }
 
diff --git a/src/heap.h b/src/heap.h
index e908248..89b6ac4 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -62,12 +62,14 @@
   // image_file_names names specify Spaces to load based on
   // ImageWriter output.
   explicit Heap(size_t starting_size, size_t growth_limit, size_t capacity,
-                const std::string& image_file_name);
+                const std::string& image_file_name, bool concurrent_gc);
 
   ~Heap();
 
   // Allocates and initializes storage for an object instance.
-  Object* AllocObject(Class* klass, size_t num_bytes);
+  Object* AllocObject(Class* klass, size_t num_bytes)
+      LOCKS_EXCLUDED(statistics_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Check sanity of given reference. Requires the heap lock.
 #if VERIFY_OBJECT_ENABLED
@@ -86,10 +88,12 @@
 
   // Returns true if 'obj' is a live heap object, false otherwise (including for invalid addresses).
   // Requires the heap lock to be held.
-  bool IsLiveObjectLocked(const Object* obj);
+  bool IsLiveObjectLocked(const Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Initiates an explicit garbage collection.
-  void CollectGarbage(bool clear_soft_references);
+  void CollectGarbage(bool clear_soft_references)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   // Does a concurrent GC, should only be called by the GC daemon thread
   // through runtime.
@@ -100,10 +104,12 @@
   // Implements java.lang.Runtime.totalMemory.
   int64_t GetTotalMemory();
   // Implements java.lang.Runtime.freeMemory.
-  int64_t GetFreeMemory();
+  int64_t GetFreeMemory() LOCKS_EXCLUDED(statistics_lock_);
 
   // Implements VMDebug.countInstancesOfClass.
-  int64_t CountInstances(Class* c, bool count_assignable);
+  int64_t CountInstances(Class* c, bool count_assignable)
+      LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Removes the growth limit on the alloc space so it may grow to its maximum capacity. Used to
   // implement dalvik.system.VMRuntime.clearGrowthLimit.
@@ -130,14 +136,6 @@
   // true if we waited for the GC to complete.
   bool WaitForConcurrentGcToComplete();
 
-  pid_t GetLockOwner(); // For SignalCatcher.
-  void AssertLockHeld() {
-    lock_->AssertHeld();
-  }
-  void AssertLockNotHeld() {
-    lock_->AssertNotHeld();
-  }
-
   const Spaces& GetSpaces() {
     return spaces_;
   }
@@ -178,8 +176,7 @@
     verify_objects_ = false;
   }
 
-  // Callers must hold the heap lock.
-  void RecordFreeLocked(size_t freed_objects, size_t freed_bytes);
+  void RecordFree(size_t freed_objects, size_t freed_bytes) LOCKS_EXCLUDED(statistics_lock_);
 
   // Must be called if a field of an Object in the heap changes, and before any GC safe-point.
   // The call is not needed if NULL is stored in the field.
@@ -190,7 +187,8 @@
   }
 
   // Write barrier for array operations that update many field positions
-  void WriteBarrierArray(const Object* dst, int /*start_offset*/, size_t /*length TODO: element_count or byte_count?*/) {
+  void WriteBarrierArray(const Object* dst, int /*start_offset*/,
+                         size_t /*length TODO: element_count or byte_count?*/) {
     if (UNLIKELY(!card_marking_disabled_)) {
       card_table_->MarkCard(dst);
     }
@@ -207,34 +205,24 @@
 
   void AddFinalizerReference(Thread* self, Object* object);
 
-  size_t GetBytesAllocated() { return num_bytes_allocated_; }
-  size_t GetObjectsAllocated() { return num_objects_allocated_; }
-
-  size_t GetConcurrentStartSize() const { return concurrent_start_size_; }
-
-  void SetConcurrentStartSize(size_t size) {
-    concurrent_start_size_ = size;
-  }
-
-  size_t GetConcurrentMinFree() const { return concurrent_min_free_; }
-
-  void SetConcurrentMinFree(size_t size) {
-    concurrent_min_free_ = size;
-  }
+  size_t GetBytesAllocated() const LOCKS_EXCLUDED(statistics_lock_);
+  size_t GetObjectsAllocated() const LOCKS_EXCLUDED(statistics_lock_);
+  size_t GetConcurrentStartSize() const LOCKS_EXCLUDED(statistics_lock_);
+  size_t GetConcurrentMinFree() const LOCKS_EXCLUDED(statistics_lock_);
 
   // Functions for getting the bitmap which corresponds to an object's address.
   // This is probably slow, TODO: use better data structure like binary tree .
   Space* FindSpaceFromObject(const Object*) const;
 
-  void DumpForSigQuit(std::ostream& os);
+  void DumpForSigQuit(std::ostream& os) LOCKS_EXCLUDED(statistics_lock_);
 
   void Trim(AllocSpace* alloc_space);
 
-  HeapBitmap* GetLiveBitmap() {
+  HeapBitmap* GetLiveBitmap() SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     return live_bitmap_.get();
   }
 
-  HeapBitmap* GetMarkBitmap() {
+  HeapBitmap* GetMarkBitmap() SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     return mark_bitmap_.get();
   }
 
@@ -248,11 +236,11 @@
 
  private:
   // Allocates uninitialized storage.
-  Object* AllocateLocked(size_t num_bytes);
-  Object* AllocateLocked(AllocSpace* space, size_t num_bytes);
-
-  void Lock() EXCLUSIVE_LOCK_FUNCTION();
-  void Unlock() UNLOCK_FUNCTION();
+  Object* Allocate(size_t num_bytes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Object* Allocate(AllocSpace* space, size_t num_bytes)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Pushes a list of cleared references out to the managed heap.
   void EnqueueClearedReferences(Object** cleared_references);
@@ -260,35 +248,42 @@
   void RequestHeapTrim();
   void RequestConcurrentGC();
 
-  void RecordAllocationLocked(AllocSpace* space, const Object* object);
+  void RecordAllocation(AllocSpace* space, const Object* object)
+      LOCKS_EXCLUDED(statistics_lock_, GlobalSynchronization::heap_bitmap_lock_);
 
-  // TODO: can we teach GCC to understand the weird locking in here?
-  void CollectGarbageInternal(bool partial_gc, bool concurrent, bool clear_soft_references) NO_THREAD_SAFETY_ANALYSIS;
+  void CollectGarbageInternal(bool partial_gc, bool clear_soft_references)
+      LOCKS_EXCLUDED(gc_complete_lock_,
+                     GlobalSynchronization::heap_bitmap_lock_,
+                     GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+  void CollectGarbageMarkSweepPlan(bool partial_gc, bool clear_soft_references)
+      LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_,
+                     GlobalSynchronization::mutator_lock_);
+  void CollectGarbageConcurrentMarkSweepPlan(bool partial_gc, bool clear_soft_references)
+      LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_,
+                     GlobalSynchronization::mutator_lock_);
 
   // Given the current contents of the alloc space, increase the allowed heap footprint to match
   // the target utilization ratio.  This should only be called immediately after a full garbage
   // collection.
   void GrowForUtilization();
 
-  size_t GetPercentFree();
+  size_t GetPercentFree() EXCLUSIVE_LOCKS_REQUIRED(statistics_lock_);
 
-  void AddSpace(Space* space);
+  void AddSpace(Space* space) LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_);
 
-  void VerifyObjectLocked(const Object *obj);
+  void VerifyObjectLocked(const Object *obj)
+      SHARED_LOCKS_REQUIRED(GlobalSychronization::heap_bitmap_lock_);
 
-  void VerifyHeapLocked();
-
-  static void VerificationCallback(Object* obj, void* arg);
-
-  UniquePtr<Mutex> lock_;
-  UniquePtr<ConditionVariable> condition_;
+  static void VerificationCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSychronization::heap_bitmap_lock_);
 
   Spaces spaces_;
 
   // The alloc space which we are currently allocating into.
   AllocSpace* alloc_space_;
 
-  // The mod-union table remembers all of the referneces from the image space to the alloc /
+  // The mod-union table remembers all of the references from the image space to the alloc /
   // zygote spaces.
   UniquePtr<ModUnionTable> mod_union_table_;
 
@@ -297,20 +292,44 @@
 
   UniquePtr<CardTable> card_table_;
 
+  // True for concurrent mark sweep GC, false for mark sweep.
+  const bool concurrent_gc_;
+
+  // If we have a zygote space.
+  bool have_zygote_space_;
+
   // Used by the image writer to disable card marking on copied objects
   // TODO: remove
   bool card_marking_disabled_;
 
+  // Guards access to the state of GC, associated conditional variable is used to signal when a GC
+  // completes.
+  Mutex* gc_complete_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  UniquePtr<ConditionVariable> gc_complete_cond_ GUARDED_BY(gc_complete_lock_);
+
   // True while the garbage collector is running.
-  volatile bool is_gc_running_;
+  volatile bool is_gc_running_ GUARDED_BY(gc_complete_lock_);
+
+  // Guards access to heap statistics, some used to calculate when concurrent GC should occur.
+  // TODO: move bytes/objects allocated to thread-locals and remove need for lock?
+  Mutex* statistics_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
 
   // Bytes until concurrent GC starts.
-  size_t concurrent_start_bytes_;
+  size_t concurrent_start_bytes_ GUARDED_BY(statistics_lock_);
   size_t concurrent_start_size_;
   size_t concurrent_min_free_;
 
-  UniquePtr<HeapBitmap> live_bitmap_;
-  UniquePtr<HeapBitmap> mark_bitmap_;
+  // Number of bytes allocated.  Adjusted after each allocation and free.
+  size_t num_bytes_allocated_ GUARDED_BY(statistics_lock_);
+
+  // Number of objects allocated.  Adjusted after each allocation and free.
+  size_t num_objects_allocated_ GUARDED_BY(statistics_lock_);
+
+  // Last trim time
+  uint64_t last_trim_time_;
+
+  UniquePtr<HeapBitmap> live_bitmap_ GUARDED_BY(GlobalSynchronization::heap_bitmap_lock_);
+  UniquePtr<HeapBitmap> mark_bitmap_ GUARDED_BY(GlobalSynchronization::heap_bitmap_lock_);
 
   // True while the garbage collector is trying to signal the GC daemon thread.
   // This flag is needed to prevent recursion from occurring when the JNI calls
@@ -318,20 +337,11 @@
   bool try_running_gc_;
 
   // Used to ensure that we don't ever recursively request GC.
-  bool requesting_gc_;
+  volatile bool requesting_gc_;
 
   // Mark stack that we reuse to avoid re-allocating the mark stack
   UniquePtr<MarkStack> mark_stack_;
 
-  // Number of bytes allocated.  Adjusted after each allocation and free.
-  size_t num_bytes_allocated_;
-
-  // Number of objects allocated.  Adjusted after each allocation and free.
-  size_t num_objects_allocated_;
-
-  // Last trim time
-  uint64_t last_trim_time_;
-
   // offset of java.lang.ref.Reference.referent
   MemberOffset reference_referent_offset_;
 
@@ -347,9 +357,6 @@
   // offset of java.lang.ref.FinalizerReference.zombie
   MemberOffset finalizer_reference_zombie_offset_;
 
-  // If we have a zygote space.
-  bool have_zygote_space_;
-
   // Target ideal heap utilization ratio
   float target_utilization_;
 
diff --git a/src/heap_bitmap.h b/src/heap_bitmap.h
index 4333199..98b42b3 100644
--- a/src/heap_bitmap.h
+++ b/src/heap_bitmap.h
@@ -25,13 +25,15 @@
 
   class HeapBitmap {
    public:
-    bool Test(const Object* obj) {
+    bool Test(const Object* obj)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
       SpaceBitmap* bitmap = GetSpaceBitmap(obj);
       DCHECK(bitmap != NULL);
       return bitmap->Test(obj);
     }
 
-    void Clear(const Object* obj) {
+    void Clear(const Object* obj)
+        EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
       SpaceBitmap* bitmap = GetSpaceBitmap(obj);
       DCHECK(bitmap != NULL)
         << "tried to clear object "
@@ -40,7 +42,8 @@
       return bitmap->Clear(obj);
     }
 
-    void Set(const Object* obj) {
+    void Set(const Object* obj)
+        EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
       SpaceBitmap* bitmap = GetSpaceBitmap(obj);
       DCHECK(bitmap != NULL)
         << "tried to mark object "
@@ -59,7 +62,8 @@
       return NULL;
     }
 
-    void Walk(SpaceBitmap::Callback* callback, void* arg) {
+    void Walk(SpaceBitmap::Callback* callback, void* arg)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
       // TODO: C++0x auto
       for (Bitmaps::iterator cur = bitmaps_.begin(); cur != bitmaps_.end(); ++cur) {
         (*cur)->Walk(callback, arg);
@@ -67,7 +71,8 @@
     }
 
     // Find and replace a bitmap pointer, this is used by for the bitmap swapping in the GC.
-    void ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap);
+    void ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap)
+        EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
     HeapBitmap(Heap* heap) : heap_(heap) {
 
diff --git a/src/heap_test.cc b/src/heap_test.cc
index 48aa425..d846db5 100644
--- a/src/heap_test.cc
+++ b/src/heap_test.cc
@@ -32,16 +32,18 @@
 }
 
 TEST_F(HeapTest, GarbageCollectClassLinkerInit) {
-  // garbage is created during ClassLinker::Init
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    // garbage is created during ClassLinker::Init
 
-  Class* c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
-  for (size_t i = 0; i < 1024; ++i) {
-    SirtRef<ObjectArray<Object> > array(ObjectArray<Object>::Alloc(c, 2048));
-    for (size_t j = 0; j < 2048; ++j) {
-      array->Set(j, String::AllocFromModifiedUtf8("hello, world!"));
+    Class* c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
+    for (size_t i = 0; i < 1024; ++i) {
+      SirtRef<ObjectArray<Object> > array(ObjectArray<Object>::Alloc(c, 2048));
+      for (size_t j = 0; j < 2048; ++j) {
+        array->Set(j, String::AllocFromModifiedUtf8("hello, world!"));
+      }
     }
   }
-
   Runtime::Current()->GetHeap()->CollectGarbage(false);
 }
 
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index d806d71..d0c87be 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -47,7 +47,7 @@
 #include "object_utils.h"
 #include "os.h"
 #include "safe_map.h"
-#include "scoped_heap_lock.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "stringprintf.h"
 #include "thread_list.h"
@@ -165,8 +165,8 @@
 typedef HprofId HprofStringId;
 typedef HprofId HprofObjectId;
 typedef HprofId HprofClassObjectId;
-typedef std::set<const Class*> ClassSet;
-typedef std::set<const Class*>::iterator ClassSetIterator;
+typedef std::set<Class*> ClassSet;
+typedef std::set<Class*>::iterator ClassSetIterator;
 typedef SafeMap<std::string, size_t> StringMap;
 typedef SafeMap<std::string, size_t>::iterator StringMapIterator;
 
@@ -401,11 +401,16 @@
     free(body_data_ptr_);
   }
 
-  void Dump() {
+  void Dump()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_) {
     // Walk the roots and the heap.
     current_record_.StartNewRecord(body_fp_, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME);
     Runtime::Current()->VisitRoots(RootVisitor, this);
-    Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(HeapBitmapCallback, this);
+    {
+      ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+      Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(HeapBitmapCallback, this);
+    }
     current_record_.StartNewRecord(body_fp_, HPROF_TAG_HEAP_DUMP_END, HPROF_TIME);
     current_record_.Flush();
     fflush(body_fp_);
@@ -464,27 +469,29 @@
   }
 
  private:
-  static void RootVisitor(const Object* obj, void* arg) {
+  static void RootVisitor(const Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(arg != NULL);
     Hprof* hprof = reinterpret_cast<Hprof*>(arg);
     hprof->VisitRoot(obj);
   }
 
-  static void HeapBitmapCallback(Object* obj, void* arg) {
+  static void HeapBitmapCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(obj != NULL);
     CHECK(arg != NULL);
     Hprof* hprof = reinterpret_cast<Hprof*>(arg);
     hprof->DumpHeapObject(obj);
   }
 
-  void VisitRoot(const Object* obj);
+  void VisitRoot(const Object* obj) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  int DumpHeapObject(const Object* obj);
+  int DumpHeapObject(Object* obj) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void Finish() {
   }
 
-  int WriteClassTable() {
+  int WriteClassTable() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     HprofRecord* rec = &current_record_;
     uint32_t nextSerialNumber = 1;
 
@@ -551,7 +558,8 @@
 
   int MarkRootObject(const Object* obj, jobject jniObj);
 
-  HprofClassObjectId LookupClassId(const Class* c) {
+  HprofClassObjectId LookupClassId(Class* c)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (c == NULL) {
       // c is the superclass of java.lang.Object or a primitive
       return (HprofClassObjectId)0;
@@ -585,7 +593,8 @@
     return id;
   }
 
-  HprofStringId LookupClassNameId(const Class* c) {
+  HprofStringId LookupClassNameId(const Class* c)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return LookupStringId(PrettyDescriptor(c));
   }
 
@@ -807,7 +816,7 @@
   return HPROF_NULL_STACK_TRACE;
 }
 
-int Hprof::DumpHeapObject(const Object* obj) {
+int Hprof::DumpHeapObject(Object* obj) {
   HprofRecord* rec = &current_record_;
   HprofHeapId desiredHeap = false ? HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP; // TODO: zygote objects?
 
@@ -847,7 +856,7 @@
     // allocated which hasn't been initialized yet.
   } else {
     if (obj->IsClass()) {
-      const Class* thisClass = obj->AsClass();
+      Class* thisClass = obj->AsClass();
       // obj is a ClassObject.
       size_t sFieldCount = thisClass->NumStaticFields();
       if (sFieldCount != 0) {
@@ -1053,15 +1062,11 @@
 // Otherwise, "filename" is used to create an output file.
 void DumpHeap(const char* filename, int fd, bool direct_to_ddms) {
   CHECK(filename != NULL);
-  ScopedHeapLock heap_lock;
-  ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
 
-  ThreadList* thread_list = Runtime::Current()->GetThreadList();
-  thread_list->SuspendAll();
-
+  Runtime::Current()->GetThreadList()->SuspendAll();
   Hprof hprof(filename, fd, direct_to_ddms);
   hprof.Dump();
-  thread_list->ResumeAll();
+  Runtime::Current()->GetThreadList()->ResumeAll();
 }
 
 }  // namespace hprof
diff --git a/src/image.h b/src/image.h
index 6286411..253b762 100644
--- a/src/image.h
+++ b/src/image.h
@@ -94,7 +94,8 @@
     kImageRootsMax,
   };
 
-  Object* GetImageRoot(ImageRoot image_root) const {
+  Object* GetImageRoot(ImageRoot image_root) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetImageRoots()->Get(image_root);
   }
 
diff --git a/src/image_test.cc b/src/image_test.cc
index f9c2d1c..9c947c1 100644
--- a/src/image_test.cc
+++ b/src/image_test.cc
@@ -32,19 +32,21 @@
 
 TEST_F(ImageTest, WriteRead) {
   ScratchFile tmp_oat;
-  std::vector<const DexFile*> dex_files;
-  dex_files.push_back(java_lang_dex_file_);
-  bool success_oat = OatWriter::Create(tmp_oat.GetFile(), NULL, dex_files, 0, "", *compiler_.get());
-  ASSERT_TRUE(success_oat);
+  {
+    ScopedObjectAccess soa(Thread::Current());
+    std::vector<const DexFile*> dex_files;
+    dex_files.push_back(java_lang_dex_file_);
+    bool success_oat = OatWriter::Create(tmp_oat.GetFile(), NULL, dex_files, 0, "", *compiler_.get());
+    ASSERT_TRUE(success_oat);
 
-  // Force all system classes into memory
-  for (size_t i = 0; i < java_lang_dex_file_->NumClassDefs(); ++i) {
-    const DexFile::ClassDef& class_def = java_lang_dex_file_->GetClassDef(i);
-    const char* descriptor = java_lang_dex_file_->GetClassDescriptor(class_def);
-    Class* klass = class_linker_->FindSystemClass(descriptor);
-    EXPECT_TRUE(klass != NULL) << descriptor;
+    // Force all system classes into memory
+    for (size_t i = 0; i < java_lang_dex_file_->NumClassDefs(); ++i) {
+      const DexFile::ClassDef& class_def = java_lang_dex_file_->GetClassDef(i);
+      const char* descriptor = java_lang_dex_file_->GetClassDescriptor(class_def);
+      Class* klass = class_linker_->FindSystemClass(descriptor);
+      EXPECT_TRUE(klass != NULL) << descriptor;
+    }
   }
-
   ImageWriter writer(NULL);
   ScratchFile tmp_image;
   const uintptr_t requested_image_base = 0x60000000;
@@ -81,7 +83,15 @@
   image.append(tmp_image.GetFilename());
   options.push_back(std::make_pair(image.c_str(), reinterpret_cast<void*>(NULL)));
 
-  runtime_.reset(Runtime::Create(options, false));
+  if (!Runtime::Create(options, false)) {
+    LOG(FATAL) << "Failed to create runtime";
+    return;
+  }
+  runtime_.reset(Runtime::Current());
+  // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
+  // give it away now and then switch to a more managable ScopedObjectAccess.
+  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  ScopedObjectAccess soa(Thread::Current());
   ASSERT_TRUE(runtime_.get() != NULL);
   class_linker_ = runtime_->GetClassLinker();
 
diff --git a/src/image_writer.cc b/src/image_writer.cc
index 59b7e80..7c88c95 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -35,6 +35,7 @@
 #include "object.h"
 #include "object_utils.h"
 #include "runtime.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "UniquePtr.h"
 #include "utils.h"
@@ -71,9 +72,13 @@
   }
   class_linker->RegisterOatFile(*oat_file_);
 
-  PruneNonImageClasses();  // Remove junk
-  ComputeLazyFieldsForImageClasses();  // Add useful information
-  ComputeEagerResolvedStrings();
+  {
+    Thread::Current()->TransitionFromSuspendedToRunnable();
+    PruneNonImageClasses();  // Remove junk
+    ComputeLazyFieldsForImageClasses();  // Add useful information
+    ComputeEagerResolvedStrings();
+    Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  }
   heap->CollectGarbage(false);  // Remove garbage
   // Trim size of alloc spaces
   // TODO: C++0x auto
@@ -90,9 +95,13 @@
   CheckNonImageClassesRemoved();
 #endif
   heap->DisableCardMarking();
-  CalculateNewObjectOffsets();
-  CopyAndFixupObjects();
-  PatchOatCodeAndMethods(compiler);
+  {
+    Thread::Current()->TransitionFromSuspendedToRunnable();
+    CalculateNewObjectOffsets();
+    CopyAndFixupObjects();
+    PatchOatCodeAndMethods(compiler);
+    Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  }
 
   UniquePtr<File> file(OS::OpenFile(image_filename.c_str(), true));
   if (file.get() == NULL) {
@@ -145,7 +154,7 @@
 void ImageWriter::ComputeLazyFieldsForImageClasses() {
   Runtime* runtime = Runtime::Current();
   ClassLinker* class_linker = runtime->GetClassLinker();
-  class_linker->VisitClasses(ComputeLazyFieldsForClassesVisitor, NULL);
+  class_linker->VisitClassesWithoutClassesLock(ComputeLazyFieldsForClassesVisitor, NULL);
 }
 
 bool ImageWriter::ComputeLazyFieldsForClassesVisitor(Class* c, void* /*arg*/) {
@@ -178,6 +187,7 @@
 
 void ImageWriter::ComputeEagerResolvedStrings() {
   // TODO: Check image spaces only?
+  ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(ComputeEagerResolvedStringsCallback, this);
 }
 
@@ -258,6 +268,7 @@
     return;
   }
 
+  ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(CheckNonImageClassesRemovedCallback, this);
 }
 
@@ -392,6 +403,7 @@
   // TODO: heap validation can't handle this fix up pass
   heap->DisableObjectValidation();
   // TODO: Image spaces only?
+  ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
   heap->GetLiveBitmap()->Walk(CopyAndFixupObjectsCallback, this);
 }
 
@@ -568,38 +580,43 @@
   }
 }
 
-static Method* GetReferrerMethod(const Compiler::PatchInformation* patch) {
+static Method* GetReferrerMethod(const Compiler::PatchInformation* patch)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  ScopedObjectAccessUnchecked soa(Thread::Current());
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  DexCache* dex_cache = class_linker->FindDexCache(patch->GetDexFile());
   Method* method = class_linker->ResolveMethod(patch->GetDexFile(),
                                                patch->GetReferrerMethodIdx(),
-                                               patch->GetDexCache(),
+                                               dex_cache,
                                                NULL,
                                                patch->GetReferrerIsDirect());
   CHECK(method != NULL)
     << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx();
   CHECK(!method->IsRuntimeMethod())
     << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx();
-  CHECK(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx()) == method)
+  CHECK(dex_cache->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx()) == method)
     << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx() << " "
-    << PrettyMethod(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx())) << " "
+    << PrettyMethod(dex_cache->GetResolvedMethods()->Get(patch->GetReferrerMethodIdx())) << " "
     << PrettyMethod(method);
   return method;
 }
 
-static Method* GetTargetMethod(const Compiler::PatchInformation* patch) {
+static Method* GetTargetMethod(const Compiler::PatchInformation* patch)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+  DexCache* dex_cache = class_linker->FindDexCache(patch->GetDexFile());
   Method* method = class_linker->ResolveMethod(patch->GetDexFile(),
                                                patch->GetTargetMethodIdx(),
-                                               patch->GetDexCache(),
+                                               dex_cache,
                                                NULL,
                                                patch->GetTargetIsDirect());
   CHECK(method != NULL)
     << patch->GetDexFile().GetLocation() << " " << patch->GetTargetMethodIdx();
   CHECK(!method->IsRuntimeMethod())
     << patch->GetDexFile().GetLocation() << " " << patch->GetTargetMethodIdx();
-  CHECK(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetTargetMethodIdx()) == method)
+  CHECK(dex_cache->GetResolvedMethods()->Get(patch->GetTargetMethodIdx()) == method)
     << patch->GetDexFile().GetLocation() << " " << patch->GetReferrerMethodIdx() << " "
-    << PrettyMethod(patch->GetDexCache()->GetResolvedMethods()->Get(patch->GetTargetMethodIdx())) << " "
+    << PrettyMethod(dex_cache->GetResolvedMethods()->Get(patch->GetTargetMethodIdx())) << " "
     << PrettyMethod(method);
   return method;
 }
diff --git a/src/image_writer.h b/src/image_writer.h
index 07d55dc..f768d87 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -39,7 +39,8 @@
 class ImageWriter {
  public:
   explicit ImageWriter(const std::set<std::string>* image_classes)
-      : image_end_(0), image_begin_(NULL), image_classes_(image_classes), oat_begin_(NULL) {}
+      : oat_file_(NULL), image_end_(0), image_begin_(NULL), image_classes_(image_classes),
+        oat_begin_(NULL) {}
 
   ~ImageWriter() {}
 
@@ -47,13 +48,15 @@
              uintptr_t image_begin,
              const std::string& oat_filename,
              const std::string& oat_location,
-             const Compiler& compiler);
+             const Compiler& compiler)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
  private:
   bool AllocMemory();
 
   // we use the lock word to store the offset of the object in the image
-  void AssignImageOffset(Object* object) {
+  void AssignImageOffset(Object* object)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(object != NULL);
     SetImageOffset(object, image_end_);
     image_end_ += RoundUp(object->SizeOf(), 8);  // 64-bit alignment
@@ -105,38 +108,55 @@
     return oat_begin_ + offset;
   }
 
-  bool IsImageClass(const Class* klass);
+  bool IsImageClass(const Class* klass) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void DumpImageClasses();
 
-  void ComputeLazyFieldsForImageClasses();
-  static bool ComputeLazyFieldsForClassesVisitor(Class* klass, void* arg);
+  void ComputeLazyFieldsForImageClasses()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static bool ComputeLazyFieldsForClassesVisitor(Class* klass, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Wire dex cache resolved strings to strings in the image to avoid runtime resolution
   void ComputeEagerResolvedStrings();
-  static void ComputeEagerResolvedStringsCallback(Object* obj, void* arg);
+  static void ComputeEagerResolvedStringsCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void PruneNonImageClasses();
-  static bool NonImageClassesVisitor(Class* c, void* arg);
+  void PruneNonImageClasses() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static bool NonImageClassesVisitor(Class* c, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void CheckNonImageClassesRemoved();
-  static void CheckNonImageClassesRemovedCallback(Object* obj, void* arg);
+  static void CheckNonImageClassesRemovedCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void CalculateNewObjectOffsets();
-  ObjectArray<Object>* CreateImageRoots() const;
-  static void CalculateNewObjectOffsetsCallback(Object* obj, void* arg);
+  void CalculateNewObjectOffsets() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  ObjectArray<Object>* CreateImageRoots() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void CalculateNewObjectOffsetsCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void CopyAndFixupObjects();
-  static void CopyAndFixupObjectsCallback(Object* obj, void* arg);
-  void FixupClass(const Class* orig, Class* copy);
-  void FixupMethod(const Method* orig, Method* copy);
-  void FixupObject(const Object* orig, Object* copy);
-  void FixupObjectArray(const ObjectArray<Object>* orig, ObjectArray<Object>* copy);
-  void FixupInstanceFields(const Object* orig, Object* copy);
-  void FixupStaticFields(const Class* orig, Class* copy);
-  void FixupFields(const Object* orig, Object* copy, uint32_t ref_offsets, bool is_static);
+  static void CopyAndFixupObjectsCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupClass(const Class* orig, Class* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupMethod(const Method* orig, Method* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupObject(const Object* orig, Object* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupObjectArray(const ObjectArray<Object>* orig, ObjectArray<Object>* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupInstanceFields(const Object* orig, Object* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupStaticFields(const Class* orig, Class* copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void FixupFields(const Object* orig, Object* copy, uint32_t ref_offsets, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void PatchOatCodeAndMethods(const Compiler& compiler);
-  void SetPatchLocation(const Compiler::PatchInformation* patch, uint32_t value);
+  void PatchOatCodeAndMethods(const Compiler& compiler)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetPatchLocation(const Compiler::PatchInformation* patch, uint32_t value)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   SafeMap<const Object*, size_t> offsets_;
 
diff --git a/src/indirect_reference_table.cc b/src/indirect_reference_table.cc
index 81b87ef..958531d 100644
--- a/src/indirect_reference_table.cc
+++ b/src/indirect_reference_table.cc
@@ -18,6 +18,7 @@
 #include "jni_internal.h"
 #include "reference_table.h"
 #include "runtime.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "utils.h"
 
@@ -91,7 +92,7 @@
     if (topIndex == max_entries_) {
       LOG(FATAL) << "JNI ERROR (app bug): " << kind_ << " table overflow "
                  << "(max=" << max_entries_ << ")\n"
-                 << Dumpable<IndirectReferenceTable>(*this);
+                 << MutatorLockedDumpable<IndirectReferenceTable>(*this);
     }
 
     size_t newSize = alloc_entries_ * 2;
@@ -101,13 +102,14 @@
     DCHECK_GT(newSize, alloc_entries_);
 
     table_ = reinterpret_cast<const Object**>(realloc(table_, newSize * sizeof(const Object*)));
-    slot_data_ = reinterpret_cast<IndirectRefSlot*>(realloc(slot_data_, newSize * sizeof(IndirectRefSlot)));
+    slot_data_ = reinterpret_cast<IndirectRefSlot*>(realloc(slot_data_,
+                                                            newSize * sizeof(IndirectRefSlot)));
     if (table_ == NULL || slot_data_ == NULL) {
       LOG(FATAL) << "JNI ERROR (app bug): unable to expand "
                  << kind_ << " table (from "
                  << alloc_entries_ << " to " << newSize
                  << ", max=" << max_entries_ << ")\n"
-                 << Dumpable<IndirectReferenceTable>(*this);
+                 << MutatorLockedDumpable<IndirectReferenceTable>(*this);
     }
 
     // Clear the newly-allocated slot_data_ elements.
@@ -150,9 +152,10 @@
 }
 
 void IndirectReferenceTable::AssertEmpty() {
-  if (begin() != end()) {
+  if (UNLIKELY(begin() != end())) {
+    ScopedObjectAccess soa(Thread::Current());
     LOG(FATAL) << "Internal Error: non-empty local reference table\n"
-               << Dumpable<IndirectReferenceTable>(*this);
+               << MutatorLockedDumpable<IndirectReferenceTable>(*this);
   }
 }
 
diff --git a/src/indirect_reference_table.h b/src/indirect_reference_table.h
index 710e43f..c3e17b0 100644
--- a/src/indirect_reference_table.h
+++ b/src/indirect_reference_table.h
@@ -257,7 +257,8 @@
    * Returns NULL if the table is full (max entries reached, or alloc
    * failed during expansion).
    */
-  IndirectRef Add(uint32_t cookie, const Object* obj);
+  IndirectRef Add(uint32_t cookie, const Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Given an IndirectRef in the table, return the Object it refers to.
@@ -287,7 +288,7 @@
 
   void AssertEmpty();
 
-  void Dump(std::ostream& os) const;
+  void Dump(std::ostream& os) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Return the #of entries in the entire table.  This includes holes, and
diff --git a/src/indirect_reference_table_test.cc b/src/indirect_reference_table_test.cc
index 387a2cd..1698f18 100644
--- a/src/indirect_reference_table_test.cc
+++ b/src/indirect_reference_table_test.cc
@@ -24,6 +24,7 @@
 };
 
 TEST_F(IndirectReferenceTableTest, BasicTest) {
+  ScopedObjectAccess soa(Thread::Current());
   static const size_t kTableInitial = 10;
   static const size_t kTableMax = 20;
   IndirectReferenceTable irt(kTableInitial, kTableMax, kGlobal);
diff --git a/src/intern_table.h b/src/intern_table.h
index 04c75d0..0d9e097 100644
--- a/src/intern_table.h
+++ b/src/intern_table.h
@@ -41,24 +41,27 @@
   InternTable();
 
   // Interns a potentially new string in the 'strong' table. (See above.)
-  String* InternStrong(int32_t utf16_length, const char* utf8_data);
+  String* InternStrong(int32_t utf16_length, const char* utf8_data)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Interns a potentially new string in the 'strong' table. (See above.)
-  String* InternStrong(const char* utf8_data);
+  String* InternStrong(const char* utf8_data)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Interns a potentially new string in the 'strong' table. (See above.)
-  String* InternStrong(String* s);
+  String* InternStrong(String* s) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Interns a potentially new string in the 'weak' table. (See above.)
-  String* InternWeak(String* s);
+  String* InternWeak(String* s) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Register a String trusting that it is safe to intern.
   // Used when reinitializing InternTable from an image.
-  void RegisterStrong(String* s);
+  void RegisterStrong(String* s) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg);
+  void SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
-  bool ContainsWeak(String* s);
+  bool ContainsWeak(String* s) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   size_t Size() const;
 
@@ -69,9 +72,11 @@
  private:
   typedef std::multimap<int32_t, String*> Table;
 
-  String* Insert(String* s, bool is_strong);
+  String* Insert(String* s, bool is_strong)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  String* Lookup(Table& table, String* s, uint32_t hash_code);
+  String* Lookup(Table& table, String* s, uint32_t hash_code)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   String* Insert(Table& table, String* s, uint32_t hash_code);
   void Remove(Table& table, const String* s, uint32_t hash_code);
 
diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index 52531ce..0d46076 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -24,6 +24,7 @@
 class InternTableTest : public CommonTest {};
 
 TEST_F(InternTableTest, Intern) {
+  ScopedObjectAccess soa(Thread::Current());
   InternTable intern_table;
   SirtRef<String> foo_1(intern_table.InternStrong(3, "foo"));
   SirtRef<String> foo_2(intern_table.InternStrong(3, "foo"));
@@ -41,6 +42,7 @@
 }
 
 TEST_F(InternTableTest, Size) {
+  ScopedObjectAccess soa(Thread::Current());
   InternTable t;
   EXPECT_EQ(0U, t.Size());
   t.InternStrong(3, "foo");
@@ -84,6 +86,7 @@
 }
 
 TEST_F(InternTableTest, SweepInternTableWeaks) {
+  ScopedObjectAccess soa(Thread::Current());
   InternTable t;
   t.InternStrong(3, "foo");
   t.InternStrong(3, "bar");
@@ -98,7 +101,10 @@
   TestPredicate p;
   p.Expect(s0.get());
   p.Expect(s1.get());
-  t.SweepInternTableWeaks(IsMarked, &p);
+  {
+    ReaderMutexLock mu(*GlobalSynchronization::heap_bitmap_lock_);
+    t.SweepInternTableWeaks(IsMarked, &p);
+  }
 
   EXPECT_EQ(2U, t.Size());
 
@@ -109,6 +115,7 @@
 }
 
 TEST_F(InternTableTest, ContainsWeak) {
+  ScopedObjectAccess soa(Thread::Current());
   {
     // Strongs are never weak.
     InternTable t;
diff --git a/src/jdwp/jdwp.h b/src/jdwp/jdwp.h
index 8534c8e..b80033c 100644
--- a/src/jdwp/jdwp.h
+++ b/src/jdwp/jdwp.h
@@ -78,7 +78,8 @@
   MethodId method_id;
   uint64_t dex_pc;
 };
-std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs);
+std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 bool operator==(const JdwpLocation& lhs, const JdwpLocation& rhs);
 bool operator!=(const JdwpLocation& lhs, const JdwpLocation& rhs);
 
@@ -118,7 +119,8 @@
    *
    * Returns a newly-allocated JdwpState struct on success, or NULL on failure.
    */
-  static JdwpState* Create(const JdwpOptions* options) NO_THREAD_SAFETY_ANALYSIS; // TODO: make GCC understand.
+  static JdwpState* Create(const JdwpOptions* options)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
   ~JdwpState();
 
@@ -178,7 +180,7 @@
    * The VM has finished initializing.  Only called when the debugger is
    * connected at the time initialization completes.
    */
-  bool PostVMStart();
+  bool PostVMStart() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * A location of interest has been reached.  This is used for breakpoints,
@@ -190,24 +192,30 @@
    *
    * "eventFlags" indicates the types of events that have occurred.
    */
-  bool PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags);
+  bool PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags)
+     SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * An exception has been thrown.
    *
    * Pass in a zeroed-out "*pCatchLoc" if the exception wasn't caught.
    */
-  bool PostException(const JdwpLocation* pThrowLoc, ObjectId excepId, RefTypeId excepClassId, const JdwpLocation* pCatchLoc, ObjectId thisPtr);
+  bool PostException(const JdwpLocation* pThrowLoc, ObjectId excepId, RefTypeId excepClassId,
+                     const JdwpLocation* pCatchLoc, ObjectId thisPtr)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * A thread has started or stopped.
    */
-  bool PostThreadChange(ObjectId threadId, bool start);
+  bool PostThreadChange(ObjectId threadId, bool start)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Class has been prepared.
    */
-  bool PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature, int status);
+  bool PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature,
+                        int status)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * The VM is about to stop.
@@ -215,12 +223,13 @@
   bool PostVMDeath();
 
   // Called if/when we realize we're talking to DDMS.
-  void NotifyDdmsActive();
+  void NotifyDdmsActive() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Send up a chunk of DDM data.
    */
-  void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count);
+  void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Process a request from the debugger.
@@ -237,13 +246,17 @@
    */
   bool SendRequest(ExpandBuf* pReq);
 
-  void ResetState();
+  void ResetState()
+      LOCKS_EXCLUDED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /* atomic ops to get next serial number */
   uint32_t NextRequestSerial();
   uint32_t NextEventSerial();
 
-  void Run();
+  void Run()
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
 
   /*
    * Register an event by adding it to the event list.
@@ -251,44 +264,60 @@
    * "*pEvent" must be storage allocated with jdwpEventAlloc().  The caller
    * may discard its pointer after calling this.
    */
-  JdwpError RegisterEvent(JdwpEvent* pEvent);
+  JdwpError RegisterEvent(JdwpEvent* pEvent)
+      LOCKS_EXCLUDED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Unregister an event, given the requestId.
    */
-  void UnregisterEventById(uint32_t requestId);
+  void UnregisterEventById(uint32_t requestId)
+      LOCKS_EXCLUDED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Unregister all events.
    */
-  void UnregisterAll();
+  void UnregisterAll()
+      LOCKS_EXCLUDED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   explicit JdwpState(const JdwpOptions* options);
   bool InvokeInProgress();
   bool IsConnected();
-  void SuspendByPolicy(JdwpSuspendPolicy suspend_policy);
+  void SuspendByPolicy(JdwpSuspendPolicy suspend_policy,  JDWP::ObjectId thread_self_id)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
+  void SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy,
+                                     ObjectId threadId)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void CleanupMatchList(JdwpEvent** match_list,
-                        int match_count) EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_);
+                        int match_count)
+      EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void EventFinish(ExpandBuf* pReq);
   void FindMatchingEvents(JdwpEventKind eventKind,
                           ModBasket* basket,
                           JdwpEvent** match_list,
-                          int* pMatchCount) EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_);
-  void UnregisterEvent(JdwpEvent* pEvent) EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_);
+                          int* pMatchCount)
+      EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void UnregisterEvent(JdwpEvent* pEvent)
+      EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  public: // TODO: fix privacy
   const JdwpOptions* options_;
 
  private:
   /* wait for creation of the JDWP thread */
-  Mutex thread_start_lock_;
-  ConditionVariable thread_start_cond_;
+  Mutex thread_start_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  ConditionVariable thread_start_cond_ GUARDED_BY(thread_start_lock_);
 
   pthread_t pthread_;
   Thread* thread_;
 
-  volatile int32_t debug_thread_started_;
+  volatile int32_t debug_thread_started_ GUARDED_BY(thread_start_lock_);
   ObjectId debug_thread_id_;
 
  private:
@@ -300,14 +329,14 @@
 
  private:
   // For wait-for-debugger.
-  Mutex attach_lock_;
-  ConditionVariable attach_cond_;
+  Mutex attach_lock_ ACQUIRED_AFTER(thread_start_lock_);
+  ConditionVariable attach_cond_ GUARDED_BY(attach_lock_);
 
   // Time of last debugger activity, in milliseconds.
   int64_t last_activity_time_ms_;
 
   // Global counters and a mutex to protect them.
-  Mutex serial_lock_;
+  Mutex serial_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   uint32_t request_serial_ GUARDED_BY(serial_lock_);
   uint32_t event_serial_ GUARDED_BY(serial_lock_);
 
@@ -318,8 +347,8 @@
 
   // Used to synchronize suspension of the event thread (to avoid receiving "resume"
   // events before the thread has finished suspending itself).
-  Mutex event_thread_lock_;
-  ConditionVariable event_thread_cond_;
+  Mutex event_thread_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  ConditionVariable event_thread_cond_ GUARDED_BY(event_thread_lock_);
   ObjectId event_thread_id_;
 
   bool ddm_is_active_;
diff --git a/src/jdwp/jdwp_event.cc b/src/jdwp/jdwp_event.cc
index 891ba53..0e7bb99 100644
--- a/src/jdwp/jdwp_event.cc
+++ b/src/jdwp/jdwp_event.cc
@@ -374,7 +374,8 @@
  * If we find a Count mod before rejecting an event, we decrement it.  We
  * need to do this even if later mods cause us to ignore the event.
  */
-static bool ModsMatch(JdwpEvent* pEvent, ModBasket* basket) {
+static bool ModsMatch(JdwpEvent* pEvent, ModBasket* basket)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   JdwpEventMod* pMod = pEvent->mods;
 
   for (int i = pEvent->modCount; i > 0; i--, pMod++) {
@@ -452,7 +453,8 @@
  * DO NOT call this multiple times for the same eventKind, as Count mods are
  * decremented during the scan.
  */
-void JdwpState::FindMatchingEvents(JdwpEventKind eventKind, ModBasket* basket, JdwpEvent** match_list, int* pMatchCount) {
+void JdwpState::FindMatchingEvents(JdwpEventKind eventKind, ModBasket* basket,
+                                   JdwpEvent** match_list, int* pMatchCount) {
   /* start after the existing entries */
   match_list += *pMatchCount;
 
@@ -490,7 +492,7 @@
  *  SP_EVENT_THREAD - suspend ourselves
  *  SP_ALL - suspend everybody except JDWP support thread
  */
-void JdwpState::SuspendByPolicy(JdwpSuspendPolicy suspend_policy) {
+void JdwpState::SuspendByPolicy(JdwpSuspendPolicy suspend_policy, JDWP::ObjectId thread_self_id) {
   VLOG(jdwp) << "SuspendByPolicy(" << suspend_policy << ")";
   if (suspend_policy == SP_NONE) {
     return;
@@ -503,7 +505,7 @@
   }
 
   /* this is rare but possible -- see CLASS_PREPARE handling */
-  if (Dbg::GetThreadSelfId() == debug_thread_id_) {
+  if (thread_self_id == debug_thread_id_) {
     LOG(INFO) << "NOTE: SuspendByPolicy not suspending JDWP thread";
     return;
   }
@@ -524,7 +526,7 @@
     }
 
     /* grab this before posting/suspending again */
-    SetWaitForEventThread(Dbg::GetThreadSelfId());
+    SetWaitForEventThread(thread_self_id);
 
     /* leave pReq->invoke_needed_ raised so we can check reentrancy */
     Dbg::ExecuteMethod(pReq);
@@ -540,6 +542,23 @@
   }
 }
 
+void JdwpState::SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy,
+                                              ObjectId threadId) {
+  Thread* self = Thread::Current();
+  self->AssertThreadSuspensionIsAllowable();
+  /* send request and possibly suspend ourselves */
+  if (pReq != NULL) {
+    JDWP::ObjectId thread_self_id = Dbg::GetThreadSelfId();
+    self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
+    if (suspend_policy != SP_NONE) {
+      SetWaitForEventThread(threadId);
+    }
+    EventFinish(pReq);
+    SuspendByPolicy(suspend_policy, thread_self_id);
+    self->TransitionFromSuspendedToRunnable();
+  }
+}
+
 /*
  * Determine if there is a method invocation in progress in the current
  * thread.
@@ -670,17 +689,7 @@
   }
 
   /* send request and possibly suspend ourselves */
-  if (pReq != NULL) {
-    int old_state = Dbg::ThreadWaiting();
-    if (suspend_policy != SP_NONE) {
-      SetWaitForEventThread(threadId);
-    }
-
-    EventFinish(pReq);
-
-    SuspendByPolicy(suspend_policy);
-    Dbg::ThreadContinuing(old_state);
-  }
+  SendRequestAndPossiblySuspend(pReq, suspend_policy, threadId);
 
   return true;
 }
@@ -787,18 +796,7 @@
     CleanupMatchList(match_list, match_count);
   }
 
-  /* send request and possibly suspend ourselves */
-  if (pReq != NULL) {
-    int old_state = Dbg::ThreadWaiting();
-    if (suspend_policy != SP_NONE) {
-      SetWaitForEventThread(basket.threadId);
-    }
-
-    EventFinish(pReq);
-
-    SuspendByPolicy(suspend_policy);
-    Dbg::ThreadContinuing(old_state);
-  }
+  SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
 
   return match_count != 0;
 }
@@ -859,17 +857,7 @@
     CleanupMatchList(match_list, match_count);
   }
 
-  /* send request and possibly suspend ourselves */
-  if (pReq != NULL) {
-    int old_state = Dbg::ThreadWaiting();
-    if (suspend_policy != SP_NONE) {
-      SetWaitForEventThread(basket.threadId);
-    }
-    EventFinish(pReq);
-
-    SuspendByPolicy(suspend_policy);
-    Dbg::ThreadContinuing(old_state);
-  }
+  SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
 
   return match_count != 0;
 }
@@ -968,18 +956,7 @@
     CleanupMatchList(match_list, match_count);
   }
 
-  /* send request and possibly suspend ourselves */
-  if (pReq != NULL) {
-    int old_state = Dbg::ThreadWaiting();
-    if (suspend_policy != SP_NONE) {
-      SetWaitForEventThread(basket.threadId);
-    }
-
-    EventFinish(pReq);
-
-    SuspendByPolicy(suspend_policy);
-    Dbg::ThreadContinuing(old_state);
-  }
+  SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
 
   return match_count != 0;
 }
@@ -990,7 +967,8 @@
  * Valid mods:
  *  Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude
  */
-bool JdwpState::PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature, int status) {
+bool JdwpState::PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature,
+                                 int status) {
   ModBasket basket;
 
   memset(&basket, 0, sizeof(basket));
@@ -1049,17 +1027,7 @@
     CleanupMatchList(match_list, match_count);
   }
 
-  /* send request and possibly suspend ourselves */
-  if (pReq != NULL) {
-    int old_state = Dbg::ThreadWaiting();
-    if (suspend_policy != SP_NONE) {
-      SetWaitForEventThread(basket.threadId);
-    }
-    EventFinish(pReq);
-
-    SuspendByPolicy(suspend_policy);
-    Dbg::ThreadContinuing(old_state);
-  }
+  SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
 
   return match_count != 0;
 }
@@ -1105,9 +1073,10 @@
   /*
    * Make sure we're in VMWAIT in case the write blocks.
    */
-  int old_state = Dbg::ThreadWaiting();
+  Thread* self = Thread::Current();
+  self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
   (*transport_->sendBufferedRequest)(this, wrapiov, iov_count + 1);
-  Dbg::ThreadContinuing(old_state);
+  self->TransitionFromSuspendedToRunnable();
 }
 
 }  // namespace JDWP
diff --git a/src/jdwp/jdwp_handler.cc b/src/jdwp/jdwp_handler.cc
index 36fbaf1..fbe9192 100644
--- a/src/jdwp/jdwp_handler.cc
+++ b/src/jdwp/jdwp_handler.cc
@@ -91,13 +91,16 @@
  */
 static JdwpError FinishInvoke(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply,
                               ObjectId thread_id, ObjectId object_id,
-                              RefTypeId class_id, MethodId method_id, bool is_constructor) {
+                              RefTypeId class_id, MethodId method_id, bool is_constructor)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   CHECK(!is_constructor || object_id != 0);
 
   uint32_t arg_count = Read4BE(&buf);
 
   VLOG(jdwp) << StringPrintf("    --> thread_id=%#llx object_id=%#llx", thread_id, object_id);
-  VLOG(jdwp) << StringPrintf("        class_id=%#llx method_id=%x %s.%s", class_id, method_id, Dbg::GetClassName(class_id).c_str(), Dbg::GetMethodName(class_id, method_id).c_str());
+  VLOG(jdwp) << StringPrintf("        class_id=%#llx method_id=%x %s.%s", class_id,
+                             method_id, Dbg::GetClassName(class_id).c_str(),
+                             Dbg::GetMethodName(class_id, method_id).c_str());
   VLOG(jdwp) << StringPrintf("        %d args:", arg_count);
 
   UniquePtr<JdwpTag[]> argTypes(arg_count > 0 ? new JdwpTag[arg_count] : NULL);
@@ -110,7 +113,9 @@
   }
 
   uint32_t options = Read4BE(&buf);  /* enum InvokeOptions bit flags */
-  VLOG(jdwp) << StringPrintf("        options=0x%04x%s%s", options, (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "", (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : "");
+  VLOG(jdwp) << StringPrintf("        options=0x%04x%s%s", options,
+                             (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "",
+                             (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : "");
 
   JdwpTag resultTag;
   uint64_t resultValue;
@@ -155,7 +160,8 @@
 /*
  * Request for version info.
  */
-static JdwpError VM_Version(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_Version(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   /* text information on runtime version */
   std::string version(StringPrintf("Android Runtime %s", Runtime::Current()->GetVersion()));
   expandBufAddUtf8String(pReply, version);
@@ -175,7 +181,8 @@
  * referenceTypeID.  We need to send back more than one if the class has
  * been loaded by multiple class loaders.
  */
-static JdwpError VM_ClassesBySignature(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError VM_ClassesBySignature(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::string classDescriptor(ReadNewUtf8String(&buf));
   VLOG(jdwp) << "  Req for class by signature '" << classDescriptor << "'";
 
@@ -207,7 +214,8 @@
  * We exclude ourselves from the list, because we don't allow ourselves
  * to be suspended, and that violates some JDWP expectations.
  */
-static JdwpError VM_AllThreads(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_AllThreads(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::vector<ObjectId> thread_ids;
   Dbg::GetThreads(0, thread_ids);
 
@@ -222,7 +230,8 @@
 /*
  * List all thread groups that do not have a parent.
  */
-static JdwpError VM_TopLevelThreadGroups(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_TopLevelThreadGroups(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   /*
    * TODO: maintain a list of parentless thread groups in the VM.
    *
@@ -244,7 +253,8 @@
  *
  * All IDs are 8 bytes.
  */
-static JdwpError VM_IDSizes(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_IDSizes(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   expandBufAdd4BE(pReply, sizeof(FieldId));
   expandBufAdd4BE(pReply, sizeof(MethodId));
   expandBufAdd4BE(pReply, sizeof(ObjectId));
@@ -253,7 +263,8 @@
   return ERR_NONE;
 }
 
-static JdwpError VM_Dispose(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError VM_Dispose(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Dbg::Disposed();
   return ERR_NONE;
 }
@@ -264,7 +275,8 @@
  *
  * This needs to increment the "suspend count" on all threads.
  */
-static JdwpError VM_Suspend(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError VM_Suspend(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Dbg::SuspendVM();
   return ERR_NONE;
 }
@@ -272,7 +284,8 @@
 /*
  * Resume execution.  Decrements the "suspend count" of all threads.
  */
-static JdwpError VM_Resume(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError VM_Resume(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Dbg::ResumeVM();
   return ERR_NONE;
 }
@@ -280,7 +293,8 @@
 /*
  * The debugger wants the entire VM to exit.
  */
-static JdwpError VM_Exit(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError VM_Exit(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   uint32_t exitCode = Get4BE(buf);
 
   LOG(WARNING) << "Debugger is telling the VM to exit with code=" << exitCode;
@@ -295,7 +309,8 @@
  * (Ctrl-Shift-I in Eclipse on an array of objects causes it to create the
  * string "java.util.Arrays".)
  */
-static JdwpError VM_CreateString(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError VM_CreateString(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::string str(ReadNewUtf8String(&buf));
   VLOG(jdwp) << "  Req to create string '" << str << "'";
   ObjectId stringId = Dbg::CreateString(str);
@@ -309,7 +324,8 @@
 /*
  * Tell the debugger what we are capable of.
  */
-static JdwpError VM_Capabilities(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_Capabilities(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   expandBufAdd1(pReply, false);   /* canWatchFieldModification */
   expandBufAdd1(pReply, false);   /* canWatchFieldAccess */
   expandBufAdd1(pReply, false);   /* canGetBytecodes */
@@ -320,7 +336,8 @@
   return ERR_NONE;
 }
 
-static JdwpError VM_ClassPaths(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_ClassPaths(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   expandBufAddUtf8String(pReply, "/");
 
   std::vector<std::string> class_path;
@@ -345,14 +362,16 @@
  *
  * Currently does nothing.
  */
-static JdwpError VM_DisposeObjects(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError VM_DisposeObjects(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return ERR_NONE;
 }
 
 /*
  * Tell the debugger what we are capable of.
  */
-static JdwpError VM_CapabilitiesNew(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_CapabilitiesNew(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   expandBufAdd1(pReply, false);   /* canWatchFieldModification */
   expandBufAdd1(pReply, false);   /* canWatchFieldAccess */
   expandBufAdd1(pReply, false);   /* canGetBytecodes */
@@ -382,7 +401,8 @@
   return ERR_NONE;
 }
 
-static JdwpError VM_AllClassesImpl(ExpandBuf* pReply, bool descriptor_and_status, bool generic) {
+static JdwpError VM_AllClassesImpl(ExpandBuf* pReply, bool descriptor_and_status, bool generic)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::vector<JDWP::RefTypeId> classes;
   Dbg::GetClassList(classes);
 
@@ -412,15 +432,18 @@
   return ERR_NONE;
 }
 
-static JdwpError VM_AllClasses(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_AllClasses(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return VM_AllClassesImpl(pReply, true, false);
 }
 
-static JdwpError VM_AllClassesWithGeneric(JdwpState*, const uint8_t*, int, ExpandBuf* pReply) {
+static JdwpError VM_AllClassesWithGeneric(JdwpState*, const uint8_t*, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return VM_AllClassesImpl(pReply, true, true);
 }
 
-static JdwpError RT_Modifiers(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_Modifiers(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   return Dbg::GetModifiers(refTypeId, pReply);
 }
@@ -428,7 +451,8 @@
 /*
  * Get values from static fields in a reference type.
  */
-static JdwpError RT_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   uint32_t field_count = Read4BE(&buf);
   expandBufAdd4BE(pReply, field_count);
@@ -445,7 +469,8 @@
 /*
  * Get the name of the source file in which a reference type was declared.
  */
-static JdwpError RT_SourceFile(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_SourceFile(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   std::string source_file;
   JdwpError status = Dbg::GetSourceFile(refTypeId, source_file);
@@ -459,7 +484,8 @@
 /*
  * Return the current status of the reference type.
  */
-static JdwpError RT_Status(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_Status(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   JDWP::JdwpTypeTag type_tag;
   uint32_t class_status;
@@ -474,7 +500,8 @@
 /*
  * Return interfaces implemented directly by this class.
  */
-static JdwpError RT_Interfaces(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_Interfaces(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   VLOG(jdwp) << StringPrintf("  Req for interfaces in %#llx (%s)", refTypeId, Dbg::GetClassName(refTypeId).c_str());
   return Dbg::OutputDeclaredInterfaces(refTypeId, pReply);
@@ -483,7 +510,8 @@
 /*
  * Return the class object corresponding to this type.
  */
-static JdwpError RT_ClassObject(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_ClassObject(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   ObjectId classObjectId;
   JdwpError status = Dbg::GetClassObject(refTypeId, classObjectId);
@@ -500,12 +528,15 @@
  *
  * JDB seems interested, but DEX files don't currently support this.
  */
-static JdwpError RT_SourceDebugExtension(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError RT_SourceDebugExtension(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   /* referenceTypeId in, string out */
   return ERR_ABSENT_INFORMATION;
 }
 
-static JdwpError RT_Signature(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply, bool with_generic) {
+static JdwpError RT_Signature(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply,
+                              bool with_generic)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
 
   VLOG(jdwp) << StringPrintf("  Req for signature of refTypeId=%#llx", refTypeId);
@@ -522,11 +553,14 @@
   return ERR_NONE;
 }
 
-static JdwpError RT_Signature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError RT_Signature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return RT_Signature(state, buf, dataLen, pReply, false);
 }
 
-static JdwpError RT_SignatureWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError RT_SignatureWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen,
+                                         ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return RT_Signature(state, buf, dataLen, pReply, true);
 }
 
@@ -534,12 +568,14 @@
  * Return the instance of java.lang.ClassLoader that loaded the specified
  * reference type, or null if it was loaded by the system loader.
  */
-static JdwpError RT_ClassLoader(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_ClassLoader(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   return Dbg::GetClassLoader(refTypeId, pReply);
 }
 
-static std::string Describe(const RefTypeId& refTypeId) {
+static std::string Describe(const RefTypeId& refTypeId)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::string signature("unknown");
   Dbg::GetSignature(refTypeId, signature);
   return StringPrintf("refTypeId=%#llx (%s)", refTypeId, signature.c_str());
@@ -549,14 +585,16 @@
  * Given a referenceTypeId, return a block of stuff that describes the
  * fields declared by a class.
  */
-static JdwpError RT_FieldsWithGeneric(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_FieldsWithGeneric(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   VLOG(jdwp) << "  Req for fields in " << Describe(refTypeId);
   return Dbg::OutputDeclaredFields(refTypeId, true, pReply);
 }
 
 // Obsolete equivalent of FieldsWithGeneric, without the generic type information.
-static JdwpError RT_Fields(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_Fields(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   VLOG(jdwp) << "  Req for fields in " << Describe(refTypeId);
   return Dbg::OutputDeclaredFields(refTypeId, false, pReply);
@@ -566,14 +604,16 @@
  * Given a referenceTypeID, return a block of goodies describing the
  * methods declared by a class.
  */
-static JdwpError RT_MethodsWithGeneric(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_MethodsWithGeneric(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   VLOG(jdwp) << "  Req for methods in " << Describe(refTypeId);
   return Dbg::OutputDeclaredMethods(refTypeId, true, pReply);
 }
 
 // Obsolete equivalent of MethodsWithGeneric, without the generic type information.
-static JdwpError RT_Methods(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError RT_Methods(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   VLOG(jdwp) << "  Req for methods in " << Describe(refTypeId);
   return Dbg::OutputDeclaredMethods(refTypeId, false, pReply);
@@ -582,7 +622,8 @@
 /*
  * Return the immediate superclass of a class.
  */
-static JdwpError CT_Superclass(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError CT_Superclass(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId class_id = ReadRefTypeId(&buf);
   RefTypeId superClassId;
   JdwpError status = Dbg::GetSuperclass(class_id, superClassId);
@@ -596,7 +637,8 @@
 /*
  * Set static class values.
  */
-static JdwpError CT_SetValues(JdwpState* , const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError CT_SetValues(JdwpState* , const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId class_id = ReadRefTypeId(&buf);
   uint32_t values = Read4BE(&buf);
 
@@ -624,7 +666,9 @@
  * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on
  * values in the "variables" display.
  */
-static JdwpError CT_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError CT_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen,
+                                 ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId class_id = ReadRefTypeId(&buf);
   ObjectId thread_id = ReadObjectId(&buf);
   MethodId method_id = ReadMethodId(&buf);
@@ -639,7 +683,9 @@
  * Example: in IntelliJ, create a watch on "new String(myByteArray)" to
  * see the contents of a byte[] as a string.
  */
-static JdwpError CT_NewInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError CT_NewInstance(JdwpState* state, const uint8_t* buf, int dataLen,
+                                ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId class_id = ReadRefTypeId(&buf);
   ObjectId thread_id = ReadObjectId(&buf);
   MethodId method_id = ReadMethodId(&buf);
@@ -659,7 +705,8 @@
 /*
  * Create a new array object of the requested type and length.
  */
-static JdwpError AT_newInstance(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError AT_newInstance(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId arrayTypeId = ReadRefTypeId(&buf);
   uint32_t length = Read4BE(&buf);
 
@@ -680,7 +727,8 @@
 /*
  * Return line number information for the method, if present.
  */
-static JdwpError M_LineTable(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError M_LineTable(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId refTypeId = ReadRefTypeId(&buf);
   MethodId method_id = ReadMethodId(&buf);
 
@@ -691,11 +739,15 @@
   return ERR_NONE;
 }
 
-static JdwpError M_VariableTable(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply, bool generic) {
+static JdwpError M_VariableTable(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply,
+                                 bool generic)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId class_id = ReadRefTypeId(&buf);
   MethodId method_id = ReadMethodId(&buf);
 
-  VLOG(jdwp) << StringPrintf("  Req for LocalVarTab in class=%s method=%s", Dbg::GetClassName(class_id).c_str(), Dbg::GetMethodName(class_id, method_id).c_str());
+  VLOG(jdwp) << StringPrintf("  Req for LocalVarTab in class=%s method=%s",
+                             Dbg::GetClassName(class_id).c_str(),
+                             Dbg::GetMethodName(class_id, method_id).c_str());
 
   // We could return ERR_ABSENT_INFORMATION here if the DEX file was built without local variable
   // information. That will cause Eclipse to make a best-effort attempt at displaying local
@@ -705,11 +757,15 @@
   return ERR_NONE;
 }
 
-static JdwpError M_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError M_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen,
+                                 ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return M_VariableTable(state, buf, dataLen, pReply, false);
 }
 
-static JdwpError M_VariableTableWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError M_VariableTableWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen,
+                                            ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return M_VariableTable(state, buf, dataLen, pReply, true);
 }
 
@@ -720,7 +776,8 @@
  * This can get called on different things, e.g. thread_id gets
  * passed in here.
  */
-static JdwpError OR_ReferenceType(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError OR_ReferenceType(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId object_id = ReadObjectId(&buf);
   VLOG(jdwp) << StringPrintf("  Req for type of object_id=%#llx", object_id);
   return Dbg::GetReferenceType(object_id, pReply);
@@ -729,7 +786,8 @@
 /*
  * Get values from the fields of an object.
  */
-static JdwpError OR_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError OR_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId object_id = ReadObjectId(&buf);
   uint32_t field_count = Read4BE(&buf);
 
@@ -751,7 +809,8 @@
 /*
  * Set values in the fields of an object.
  */
-static JdwpError OR_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError OR_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId object_id = ReadObjectId(&buf);
   uint32_t field_count = Read4BE(&buf);
 
@@ -785,7 +844,9 @@
  * object), it will try to invoke the object's toString() function.  This
  * feature becomes crucial when examining ArrayLists with Eclipse.
  */
-static JdwpError OR_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError OR_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen,
+                                 ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId object_id = ReadObjectId(&buf);
   ObjectId thread_id = ReadObjectId(&buf);
   RefTypeId class_id = ReadRefTypeId(&buf);
@@ -797,7 +858,8 @@
 /*
  * Disable garbage collection of the specified object.
  */
-static JdwpError OR_DisableCollection(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError OR_DisableCollection(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // this is currently a no-op
   return ERR_NONE;
 }
@@ -805,7 +867,8 @@
 /*
  * Enable garbage collection of the specified object.
  */
-static JdwpError OR_EnableCollection(JdwpState*, const uint8_t*, int, ExpandBuf*) {
+static JdwpError OR_EnableCollection(JdwpState*, const uint8_t*, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // this is currently a no-op
   return ERR_NONE;
 }
@@ -813,7 +876,8 @@
 /*
  * Determine whether an object has been garbage collected.
  */
-static JdwpError OR_IsCollected(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError OR_IsCollected(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId object_id;
 
   object_id = ReadObjectId(&buf);
@@ -828,7 +892,8 @@
 /*
  * Return the string value in a string object.
  */
-static JdwpError SR_Value(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError SR_Value(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId stringObject = ReadObjectId(&buf);
   std::string str(Dbg::StringToUtf8(stringObject));
 
@@ -842,7 +907,8 @@
 /*
  * Return a thread's name.
  */
-static JdwpError TR_Name(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_Name(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
 
   VLOG(jdwp) << StringPrintf("  Req for name of thread %#llx", thread_id);
@@ -862,7 +928,8 @@
  * It's supposed to remain suspended even if interpreted code wants to
  * resume it; only the JDI is allowed to resume it.
  */
-static JdwpError TR_Suspend(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError TR_Suspend(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
 
   if (thread_id == Dbg::GetThreadSelfId()) {
@@ -870,14 +937,18 @@
     return ERR_THREAD_NOT_SUSPENDED;
   }
   VLOG(jdwp) << StringPrintf("  Req to suspend thread %#llx", thread_id);
-  Dbg::SuspendThread(thread_id);
-  return ERR_NONE;
+  Thread* self = Thread::Current();
+  self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
+  JdwpError result = Dbg::SuspendThread(thread_id);
+  self->TransitionFromSuspendedToRunnable();
+  return result;
 }
 
 /*
  * Resume the specified thread.
  */
-static JdwpError TR_Resume(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError TR_Resume(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
 
   if (thread_id == Dbg::GetThreadSelfId()) {
@@ -892,7 +963,8 @@
 /*
  * Return status of specified thread.
  */
-static JdwpError TR_Status(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_Status(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
 
   VLOG(jdwp) << StringPrintf("  Req for status of thread %#llx", thread_id);
@@ -914,7 +986,8 @@
 /*
  * Return the thread group that the specified thread is a member of.
  */
-static JdwpError TR_ThreadGroup(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_ThreadGroup(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
   return Dbg::GetThreadGroup(thread_id, pReply);
 }
@@ -925,7 +998,8 @@
  * If the thread isn't suspended, the error code isn't defined, but should
  * be THREAD_NOT_SUSPENDED.
  */
-static JdwpError TR_Frames(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_Frames(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
   uint32_t start_frame = Read4BE(&buf);
   uint32_t length = Read4BE(&buf);
@@ -961,7 +1035,8 @@
 /*
  * Returns the #of frames on the specified thread, which must be suspended.
  */
-static JdwpError TR_FrameCount(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_FrameCount(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
 
   if (!Dbg::ThreadExists(thread_id)) {
@@ -984,7 +1059,8 @@
 /*
  * Get the monitor that the thread is waiting on.
  */
-static JdwpError TR_CurrentContendedMonitor(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError TR_CurrentContendedMonitor(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ReadObjectId(&buf);  // thread_id
 
   // TODO: create an Object to represent the monitor (we're currently
@@ -994,14 +1070,15 @@
 }
 
 /*
- * Return the suspend count for the specified thread.
+ * Return the debug suspend count for the specified thread.
  *
  * (The thread *might* still be running -- it might not have examined
  * its suspend count recently.)
  */
-static JdwpError TR_SuspendCount(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TR_DebugSuspendCount(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
-  return Dbg::GetThreadSuspendCount(thread_id, pReply);
+  return Dbg::GetThreadDebugSuspendCount(thread_id, pReply);
 }
 
 /*
@@ -1009,7 +1086,8 @@
  *
  * The Eclipse debugger recognizes "main" and "system" as special.
  */
-static JdwpError TGR_Name(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TGR_Name(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_group_id = ReadObjectId(&buf);
   VLOG(jdwp) << StringPrintf("  Req for name of thread_group_id=%#llx", thread_group_id);
 
@@ -1022,7 +1100,8 @@
  * Returns the thread group -- if any -- that contains the specified
  * thread group.
  */
-static JdwpError TGR_Parent(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TGR_Parent(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_group_id = ReadObjectId(&buf);
 
   ObjectId parentGroup = Dbg::GetThreadGroupParent(thread_group_id);
@@ -1035,7 +1114,8 @@
  * Return the active threads and thread groups that are part of the
  * specified thread group.
  */
-static JdwpError TGR_Children(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError TGR_Children(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_group_id = ReadObjectId(&buf);
   VLOG(jdwp) << StringPrintf("  Req for threads in thread_group_id=%#llx", thread_group_id);
 
@@ -1059,7 +1139,8 @@
 /*
  * Return the #of components in the array.
  */
-static JdwpError AR_Length(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError AR_Length(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId arrayId = ReadObjectId(&buf);
   VLOG(jdwp) << StringPrintf("  Req for length of array %#llx", arrayId);
 
@@ -1078,7 +1159,8 @@
 /*
  * Return the values from an array.
  */
-static JdwpError AR_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError AR_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId arrayId = ReadObjectId(&buf);
   uint32_t firstIndex = Read4BE(&buf);
   uint32_t length = Read4BE(&buf);
@@ -1090,17 +1172,20 @@
 /*
  * Set values in an array.
  */
-static JdwpError AR_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError AR_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId arrayId = ReadObjectId(&buf);
   uint32_t firstIndex = Read4BE(&buf);
   uint32_t values = Read4BE(&buf);
 
-  VLOG(jdwp) << StringPrintf("  Req to set array values %#llx first=%d count=%d", arrayId, firstIndex, values);
+  VLOG(jdwp) << StringPrintf("  Req to set array values %#llx first=%d count=%d", arrayId,
+                             firstIndex, values);
 
   return Dbg::SetArrayElements(arrayId, firstIndex, values, buf);
 }
 
-static JdwpError CLR_VisibleClasses(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError CLR_VisibleClasses(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ReadObjectId(&buf);  // classLoaderObject
   // TODO: we should only return classes which have the given class loader as a defining or
   // initiating loader. The former would be easy; the latter is hard, because we don't have
@@ -1113,7 +1198,8 @@
  *
  * Reply with a requestID.
  */
-static JdwpError ER_Set(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError ER_Set(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   const uint8_t* origBuf = buf;
 
   uint8_t eventKind = Read1(&buf);
@@ -1282,7 +1368,8 @@
  * Clear an event.  Failure to find an event with a matching ID is a no-op
  * and does not return an error.
  */
-static JdwpError ER_Clear(JdwpState* state, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError ER_Clear(JdwpState* state, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   uint8_t eventKind;
   eventKind = Read1(&buf);
   uint32_t requestId = Read4BE(&buf);
@@ -1297,7 +1384,8 @@
 /*
  * Return the values of arguments and local variables.
  */
-static JdwpError SF_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError SF_GetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
   FrameId frame_id = ReadFrameId(&buf);
   uint32_t slots = Read4BE(&buf);
@@ -1322,7 +1410,8 @@
 /*
  * Set the values of arguments and local variables.
  */
-static JdwpError SF_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*) {
+static JdwpError SF_SetValues(JdwpState*, const uint8_t* buf, int, ExpandBuf*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
   FrameId frame_id = ReadFrameId(&buf);
   uint32_t slots = Read4BE(&buf);
@@ -1345,7 +1434,8 @@
 /*
  * Returns the value of "this" for the specified frame.
  */
-static JdwpError SF_ThisObject(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError SF_ThisObject(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ObjectId thread_id = ReadObjectId(&buf);
   FrameId frame_id = ReadFrameId(&buf);
 
@@ -1361,7 +1451,8 @@
     return rc;
   }
 
-  VLOG(jdwp) << StringPrintf("  Req for 'this' in thread_id=%#llx frame=%lld --> %#llx '%c'", thread_id, frame_id, id, static_cast<char>(tag));
+  VLOG(jdwp) << StringPrintf("  Req for 'this' in thread_id=%#llx frame=%lld --> %#llx '%c'",
+                             thread_id, frame_id, id, static_cast<char>(tag));
   expandBufAdd1(pReply, tag);
   expandBufAddObjectId(pReply, id);
 
@@ -1375,16 +1466,19 @@
  * reused, whereas ClassIds can be recycled like any other object.  (Either
  * that, or I have no idea what this is for.)
  */
-static JdwpError COR_ReflectedType(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply) {
+static JdwpError COR_ReflectedType(JdwpState*, const uint8_t* buf, int, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   RefTypeId classObjectId = ReadRefTypeId(&buf);
-  VLOG(jdwp) << StringPrintf("  Req for refTypeId for class=%#llx (%s)", classObjectId, Dbg::GetClassName(classObjectId).c_str());
+  VLOG(jdwp) << StringPrintf("  Req for refTypeId for class=%#llx (%s)", classObjectId,
+                             Dbg::GetClassName(classObjectId).c_str());
   return Dbg::GetReflectedType(classObjectId, pReply);
 }
 
 /*
  * Handle a DDM packet with a single chunk in it.
  */
-static JdwpError DDM_Chunk(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
+static JdwpError DDM_Chunk(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   uint8_t* replyBuf = NULL;
   int replyLen = -1;
 
@@ -1518,7 +1612,7 @@
   { 11,   9,  TR_CurrentContendedMonitor, "ThreadReference.CurrentContendedMonitor" },
   { 11,   10, NULL, "ThreadReference.Stop" },
   { 11,   11, NULL, "ThreadReference.Interrupt" },
-  { 11,   12, TR_SuspendCount,  "ThreadReference.SuspendCount" },
+  { 11,   12, TR_DebugSuspendCount, "ThreadReference.SuspendCount" },
   { 11,   13, NULL, "ThreadReference.OwnedMonitorsStackDepthInfo" },
   { 11,   14, NULL, "ThreadReference.ForceEarlyReturn" },
 
@@ -1612,7 +1706,8 @@
    * Tell the VM that we're running and shouldn't be interrupted by GC.
    * Do this after anything that can stall indefinitely.
    */
-  Dbg::ThreadRunning();
+  Thread* self = Thread::Current();
+  ThreadState old_state = self->TransitionFromSuspendedToRunnable();
 
   expandBufAddSpace(pReply, kJDWPHeaderLen);
 
@@ -1660,7 +1755,8 @@
   }
 
   /* tell the VM that GC is okay again */
-  Dbg::ThreadWaiting();
+  self->TransitionFromRunnableToSuspended(old_state);
+
 }
 
 }  // namespace JDWP
diff --git a/src/jdwp/jdwp_main.cc b/src/jdwp/jdwp_main.cc
index dfe83ff..beec7af 100644
--- a/src/jdwp/jdwp_main.cc
+++ b/src/jdwp/jdwp_main.cc
@@ -22,6 +22,7 @@
 #include "debugger.h"
 #include "jdwp/jdwp_priv.h"
 #include "logging.h"
+#include "scoped_thread_state_change.h"
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -88,6 +89,8 @@
     : options_(options),
       thread_start_lock_("JDWP thread start lock"),
       thread_start_cond_("JDWP thread start condition variable"),
+      pthread_(0),
+      thread_(NULL),
       debug_thread_started_(false),
       debug_thread_id_(0),
       run(false),
@@ -115,6 +118,7 @@
  * the thread is accepting network connections.
  */
 JdwpState* JdwpState::Create(const JdwpOptions* options) {
+  GlobalSynchronization::mutator_lock_->AssertNotHeld();
   UniquePtr<JdwpState> state(new JdwpState(options));
   switch (options->transport) {
   case kJdwpTransportSocket:
@@ -139,53 +143,62 @@
    * Grab a mutex or two before starting the thread.  This ensures they
    * won't signal the cond var before we're waiting.
    */
-  state->thread_start_lock_.Lock();
-  const bool should_suspend = options->suspend;
-  if (should_suspend) {
-    state->attach_lock_.Lock();
-  }
+  {
+    MutexLock thread_start_locker(state->thread_start_lock_);
+    const bool should_suspend = options->suspend;
+    if (!should_suspend) {
+      /*
+       * We have bound to a port, or are trying to connect outbound to a
+       * debugger.  Create the JDWP thread and let it continue the mission.
+       */
+      CHECK_PTHREAD_CALL(pthread_create, (&state->pthread_, NULL, StartJdwpThread, state.get()), "JDWP thread");
 
-  /*
-   * We have bound to a port, or are trying to connect outbound to a
-   * debugger.  Create the JDWP thread and let it continue the mission.
-   */
-  CHECK_PTHREAD_CALL(pthread_create, (&state->pthread_, NULL, StartJdwpThread, state.get()), "JDWP thread");
+      /*
+       * Wait until the thread finishes basic initialization.
+       * TODO: cond vars should be waited upon in a loop
+       */
+      state->thread_start_cond_.Wait(state->thread_start_lock_);
+    } else {
+      {
+        MutexLock attach_locker(state->attach_lock_);
+        /*
+         * We have bound to a port, or are trying to connect outbound to a
+         * debugger.  Create the JDWP thread and let it continue the mission.
+         */
+        CHECK_PTHREAD_CALL(pthread_create, (&state->pthread_, NULL, StartJdwpThread, state.get()), "JDWP thread");
 
-  /*
-   * Wait until the thread finishes basic initialization.
-   * TODO: cond vars should be waited upon in a loop
-   */
-  state->thread_start_cond_.Wait(state->thread_start_lock_);
-  state->thread_start_lock_.Unlock();
+        /*
+         * Wait until the thread finishes basic initialization.
+         * TODO: cond vars should be waited upon in a loop
+         */
+        state->thread_start_cond_.Wait(state->thread_start_lock_);
 
-  /*
-   * For suspend=y, wait for the debugger to connect to us or for us to
-   * connect to the debugger.
-   *
-   * The JDWP thread will signal us when it connects successfully or
-   * times out (for timeout=xxx), so we have to check to see what happened
-   * when we wake up.
-   */
-  if (should_suspend) {
-    {
-      ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
+        /*
+         * For suspend=y, wait for the debugger to connect to us or for us to
+         * connect to the debugger.
+         *
+         * The JDWP thread will signal us when it connects successfully or
+         * times out (for timeout=xxx), so we have to check to see what happened
+         * when we wake up.
+         */
+        {
+          ScopedThreadStateChange tsc(Thread::Current(), kWaitingForDebuggerToAttach);
+          state->attach_cond_.Wait(state->attach_lock_);
+        }
+      }
+      if (!state->IsActive()) {
+        LOG(ERROR) << "JDWP connection failed";
+        return NULL;
+      }
 
-      state->attach_cond_.Wait(state->attach_lock_);
-      state->attach_lock_.Unlock();
+      LOG(INFO) << "JDWP connected";
+
+      /*
+       * Ordinarily we would pause briefly to allow the debugger to set
+       * breakpoints and so on, but for "suspend=y" the VM init code will
+       * pause the VM when it sends the VM_START message.
+       */
     }
-
-    if (!state->IsActive()) {
-      LOG(ERROR) << "JDWP connection failed";
-      return NULL;
-    }
-
-    LOG(INFO) << "JDWP connected";
-
-    /*
-     * Ordinarily we would pause briefly to allow the debugger to set
-     * breakpoints and so on, but for "suspend=y" the VM init code will
-     * pause the VM when it sends the VM_START message.
-     */
   }
 
   return state.release();
@@ -280,14 +293,18 @@
    */
   thread_ = Thread::Current();
   run = true;
-  android_atomic_release_store(true, &debug_thread_started_);
 
   thread_start_lock_.Lock();
+  debug_thread_started_ = true;
   thread_start_cond_.Broadcast();
   thread_start_lock_.Unlock();
 
-  /* set the thread state to VMWAIT so GCs don't wait for us */
-  Dbg::ThreadWaiting();
+  /* set the thread state to kWaitingInMainDebuggerLoop so GCs don't wait for us */
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(thread_->GetState(), kNative);
+    thread_->SetState(kWaitingInMainDebuggerLoop);
+  }
 
   /*
    * Loop forever if we're in server mode, processing connections.  In
@@ -327,10 +344,10 @@
     /* process requests until the debugger drops */
     bool first = true;
     while (!Dbg::IsDisposed()) {
-      // sanity check -- shouldn't happen?
-      if (Thread::Current()->GetState() != kVmWait) {
-        LOG(ERROR) << "JDWP thread no longer in VMWAIT (now " << Thread::Current()->GetState() << "); resetting";
-        Dbg::ThreadWaiting();
+      {
+        // sanity check -- shouldn't happen?
+        MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+        CHECK_EQ(thread_->GetState(), kWaitingInMainDebuggerLoop);
       }
 
       if (!(*transport_->processIncoming)(this)) {
@@ -343,7 +360,10 @@
         first = false;
 
         /* set thread ID; requires object registry to be active */
-        debug_thread_id_ = Dbg::GetThreadSelfId();
+        {
+          ScopedObjectAccess soa(thread_);
+          debug_thread_id_ = Dbg::GetThreadSelfId();
+        }
 
         /* wake anybody who's waiting for us */
         MutexLock mu(attach_lock_);
@@ -357,14 +377,16 @@
       ddm_is_active_ = false;
 
       /* broadcast the disconnect; must be in RUNNING state */
-      Dbg::ThreadRunning();
+      thread_->TransitionFromSuspendedToRunnable();
       Dbg::DdmDisconnected();
-      Dbg::ThreadWaiting();
+      thread_->TransitionFromRunnableToSuspended(kWaitingInMainDebuggerLoop);
     }
 
     /* release session state, e.g. remove breakpoint instructions */
-    ResetState();
-
+    {
+      ScopedObjectAccess soa(thread_);
+      ResetState();
+    }
     /* tell the interpreter that the debugger is no longer around */
     Dbg::Disconnected();
 
@@ -377,8 +399,12 @@
     }
   }
 
-  /* back to running, for thread shutdown */
-  Dbg::ThreadRunning();
+  /* back to native, for thread shutdown */
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(thread_->GetState(), kWaitingInMainDebuggerLoop);
+    thread_->SetState(kNative);
+  }
 
   VLOG(jdwp) << "JDWP: thread detaching and exiting...";
   runtime->DetachCurrentThread();
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 22b4b2c..e1332d3 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -22,7 +22,8 @@
 #include "jni_internal.h"
 #include "mem_map.h"
 #include "runtime.h"
-#include "scoped_jni_thread_state.h"
+#include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "UniquePtr.h"
 
@@ -38,10 +39,11 @@
 
 class JniCompilerTest : public CommonTest {
  protected:
-  void CompileForTest(ClassLoader* class_loader, bool direct,
+  void CompileForTest(jobject class_loader, bool direct,
                       const char* method_name, const char* method_sig) {
+    ScopedObjectAccess soa(Thread::Current());
     // Compile the native method before starting the runtime
-    Class* c = class_linker_->FindClass("LMyClassNatives;", class_loader);
+    Class* c = class_linker_->FindClass("LMyClassNatives;", soa.Decode<ClassLoader*>(class_loader));
     Method* method;
     if (direct) {
       method = c->FindDirectMethod(method_name, method_sig);
@@ -56,15 +58,20 @@
     ASSERT_TRUE(method->GetCode() != NULL);
   }
 
-  void SetUpForTest(ClassLoader* class_loader, bool direct,
-                    const char* method_name, const char* method_sig,
+  void SetUpForTest(bool direct, const char* method_name, const char* method_sig,
                     void* native_fnptr) {
-    CompileForTest(class_loader, direct, method_name, method_sig);
-    if (!runtime_->IsStarted()) {
+    // Initialize class loader and compile method when runtime not started.
+    if (!runtime_->IsStarted()){
+      {
+        ScopedObjectAccess soa(Thread::Current());
+        class_loader_ = LoadDex("MyClassNatives");
+      }
+      CompileForTest(class_loader_, direct, method_name, method_sig);
+      // Start runtime.
+      Thread::Current()->TransitionFromSuspendedToRunnable();
       runtime_->Start();
     }
-
-    // JNI operations after runtime start
+    // JNI operations after runtime start.
     env_ = Thread::Current()->GetJniEnv();
     jklass_ = env_->FindClass("MyClassNatives");
     ASSERT_TRUE(jklass_ != NULL);
@@ -91,6 +98,8 @@
  public:
   static jclass jklass_;
   static jobject jobj_;
+  static jobject class_loader_;
+
 
  protected:
   JNIEnv* env_;
@@ -99,12 +108,17 @@
 
 jclass JniCompilerTest::jklass_;
 jobject JniCompilerTest::jobj_;
+jobject JniCompilerTest::class_loader_;
 
 int gJava_MyClassNatives_foo_calls = 0;
 void Java_MyClassNatives_foo(JNIEnv* env, jobject thisObj) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+    GlobalSynchronization::mutator_lock_->AssertNotHeld();
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -112,8 +126,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunNoArgMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "foo", "()V",
+  SetUpForTest(false, "foo", "()V",
                reinterpret_cast<void*>(&Java_MyClassNatives_foo));
 
   EXPECT_EQ(0, gJava_MyClassNatives_foo_calls);
@@ -124,26 +137,28 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunIntMethodThroughStub) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "bar", "(I)I",
+  SetUpForTest(false, "bar", "(I)I",
                NULL /* calling through stub will link with &Java_MyClassNatives_bar */);
 
+  ScopedObjectAccess soa(Thread::Current());
   std::string reason;
-  ASSERT_TRUE(Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", class_loader.get(), reason))
-      << reason;
+  ASSERT_TRUE(
+      Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<ClassLoader*>(class_loader_),
+                                                         reason)) << reason;
 
   jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24);
   EXPECT_EQ(25, result);
 }
 
 TEST_F(JniCompilerTest, CompileAndRunStaticIntMethodThroughStub) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "sbar", "(I)I",
+  SetUpForTest(true, "sbar", "(I)I",
                NULL /* calling through stub will link with &Java_MyClassNatives_sbar */);
 
+  ScopedObjectAccess soa(Thread::Current());
   std::string reason;
-  ASSERT_TRUE(Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", class_loader.get(), reason))
-      << reason;
+  ASSERT_TRUE(
+      Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<ClassLoader*>(class_loader_),
+                                                         reason)) << reason;
 
   jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42);
   EXPECT_EQ(43, result);
@@ -151,9 +166,12 @@
 
 int gJava_MyClassNatives_fooI_calls = 0;
 jint Java_MyClassNatives_fooI(JNIEnv* env, jobject thisObj, jint x) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -162,8 +180,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunIntMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooI", "(I)I",
+  SetUpForTest(false, "fooI", "(I)I",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooI));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooI_calls);
@@ -177,9 +194,12 @@
 
 int gJava_MyClassNatives_fooII_calls = 0;
 jint Java_MyClassNatives_fooII(JNIEnv* env, jobject thisObj, jint x, jint y) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -188,8 +208,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunIntIntMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooII", "(II)I",
+  SetUpForTest(false, "fooII", "(II)I",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooII));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooII_calls);
@@ -204,9 +223,12 @@
 
 int gJava_MyClassNatives_fooJJ_calls = 0;
 jlong Java_MyClassNatives_fooJJ(JNIEnv* env, jobject thisObj, jlong x, jlong y) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -215,8 +237,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunLongLongMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooJJ", "(JJ)J",
+  SetUpForTest(false, "fooJJ", "(JJ)J",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooJJ));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls);
@@ -232,9 +253,12 @@
 
 int gJava_MyClassNatives_fooDD_calls = 0;
 jdouble Java_MyClassNatives_fooDD(JNIEnv* env, jobject thisObj, jdouble x, jdouble y) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -243,8 +267,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunDoubleDoubleMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooDD", "(DD)D",
+  SetUpForTest(false, "fooDD", "(DD)D",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooDD));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooDD_calls);
@@ -261,9 +284,12 @@
 
 int gJava_MyClassNatives_fooJJ_synchronized_calls = 0;
 jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject thisObj, jlong x, jlong y) {
-  // 2 = SirtRef<ClassLoader> + thisObj
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = thisObj
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -272,8 +298,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRun_fooJJ_synchronized) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooJJ_synchronized", "(JJ)J",
+  SetUpForTest(false, "fooJJ_synchronized", "(JJ)J",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooJJ_synchronized));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_synchronized_calls);
@@ -287,9 +312,12 @@
 int gJava_MyClassNatives_fooIOO_calls = 0;
 jobject Java_MyClassNatives_fooIOO(JNIEnv* env, jobject thisObj, jint x, jobject y,
                             jobject z) {
-  // 4 = SirtRef<ClassLoader> + this + y + z
-  EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 3 = this + y + z
+  EXPECT_EQ(3U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -305,8 +333,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunIntObjectObjectMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooIOO",
+  SetUpForTest(false, "fooIOO",
                "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooIOO));
 
@@ -338,9 +365,12 @@
 
 int gJava_MyClassNatives_fooSII_calls = 0;
 jint Java_MyClassNatives_fooSII(JNIEnv* env, jclass klass, jint x, jint y) {
-  // 2 = SirtRef<ClassLoader> + klass
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = klass
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -349,8 +379,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunStaticIntIntMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "fooSII", "(II)I",
+  SetUpForTest(true, "fooSII", "(II)I",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooSII));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooSII_calls);
@@ -361,9 +390,12 @@
 
 int gJava_MyClassNatives_fooSDD_calls = 0;
 jdouble Java_MyClassNatives_fooSDD(JNIEnv* env, jclass klass, jdouble x, jdouble y) {
-  // 2 = SirtRef<ClassLoader> + klass
-  EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 1 = klass
+  EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -372,8 +404,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunStaticDoubleDoubleMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "fooSDD", "(DD)D",
+  SetUpForTest(true, "fooSDD", "(DD)D",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooSDD));
 
   EXPECT_EQ(0, gJava_MyClassNatives_fooSDD_calls);
@@ -390,9 +421,12 @@
 int gJava_MyClassNatives_fooSIOO_calls = 0;
 jobject Java_MyClassNatives_fooSIOO(JNIEnv* env, jclass klass, jint x, jobject y,
                              jobject z) {
-  // 4 = SirtRef<ClassLoader> + klass + y + z
-  EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  // 3 = klass + y + z
+  EXPECT_EQ(3U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -409,8 +443,7 @@
 
 
 TEST_F(JniCompilerTest, CompileAndRunStaticIntObjectObjectMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "fooSIOO",
+  SetUpForTest(true, "fooSIOO",
                "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooSIOO));
 
@@ -441,11 +474,13 @@
 }
 
 int gJava_MyClassNatives_fooSSIOO_calls = 0;
-jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y,
-                             jobject z) {
-  // 4 = SirtRef<ClassLoader> + klass + y + z
-  EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
-  EXPECT_EQ(kNative, Thread::Current()->GetState());
+jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y, jobject z) {
+  // 3 = klass + y + z
+  EXPECT_EQ(3U, Thread::Current()->NumStackReferences());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    EXPECT_EQ(kNative, Thread::Current()->GetState());
+  }
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -461,8 +496,7 @@
 }
 
 TEST_F(JniCompilerTest, CompileAndRunStaticSynchronizedIntObjectObjectMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "fooSSIOO",
+  SetUpForTest(true, "fooSSIOO",
                "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooSSIOO));
 
@@ -498,34 +532,42 @@
 }
 
 TEST_F(JniCompilerTest, ExceptionHandling) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
+  {
+    ASSERT_FALSE(runtime_->IsStarted());
+    ScopedObjectAccess soa(Thread::Current());
+    class_loader_ = LoadDex("MyClassNatives");
 
-  // all compilation needs to happen before SetUpForTest calls Runtime::Start
-  CompileForTest(class_loader.get(), false, "foo", "()V");
-  CompileForTest(class_loader.get(), false, "throwException", "()V");
-  CompileForTest(class_loader.get(), false, "foo", "()V");
+    // all compilation needs to happen before Runtime::Start
+    CompileForTest(class_loader_, false, "foo", "()V");
+    CompileForTest(class_loader_, false, "throwException", "()V");
+    CompileForTest(class_loader_, false, "foo", "()V");
+  }
+  // Start runtime to avoid re-initialization in SetupForTest.
+  Thread::Current()->TransitionFromSuspendedToRunnable();
+  runtime_->Start();
 
   gJava_MyClassNatives_foo_calls = 0;
 
   // Check a single call of a JNI method is ok
-  SetUpForTest(class_loader.get(), false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
+  SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
   env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
   EXPECT_EQ(1, gJava_MyClassNatives_foo_calls);
   EXPECT_FALSE(Thread::Current()->IsExceptionPending());
 
   // Get class for exception we expect to be thrown
-  Class* jlre = class_linker_->FindClass("Ljava/lang/RuntimeException;", class_loader.get());
-  SetUpForTest(class_loader.get(), false, "throwException", "()V",
+  ScopedLocalRef<jclass> jlre(env_, env_->FindClass("java/lang/RuntimeException"));
+  SetUpForTest(false, "throwException", "()V",
                reinterpret_cast<void*>(&Java_MyClassNatives_throwException));
   // Call Java_MyClassNatives_throwException (JNI method that throws exception)
   env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
   EXPECT_EQ(1, gJava_MyClassNatives_foo_calls);
-  EXPECT_TRUE(Thread::Current()->IsExceptionPending());
-  EXPECT_TRUE(Thread::Current()->GetException()->InstanceOf(jlre));
-  Thread::Current()->ClearException();
+  EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
+  ScopedLocalRef<jthrowable> exception(env_, env_->ExceptionOccurred());
+  env_->ExceptionClear();
+  EXPECT_TRUE(env_->IsInstanceOf(exception.get(), jlre.get()));
 
   // Check a single call of a JNI method is ok
-  SetUpForTest(class_loader.get(), false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
+  SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
   env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
   EXPECT_EQ(2, gJava_MyClassNatives_foo_calls);
 }
@@ -533,13 +575,13 @@
 jint Java_MyClassNatives_nativeUpCall(JNIEnv* env, jobject thisObj, jint i) {
   if (i <= 0) {
     // We want to check raw Object*/Array* below
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
 
     // Build stack trace
-    jobject internal = Thread::Current()->CreateInternalStackTrace(ts);
+    jobject internal = Thread::Current()->CreateInternalStackTrace(soa);
     jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(env, internal);
     ObjectArray<StackTraceElement>* trace_array =
-        ts.Decode<ObjectArray<StackTraceElement>*>(ste_array);
+        soa.Decode<ObjectArray<StackTraceElement>*>(ste_array);
     EXPECT_TRUE(trace_array != NULL);
     EXPECT_EQ(11, trace_array->GetLength());
 
@@ -569,8 +611,7 @@
 }
 
 TEST_F(JniCompilerTest, NativeStackTraceElement) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooI", "(I)I",
+  SetUpForTest(false, "fooI", "(I)I",
                reinterpret_cast<void*>(&Java_MyClassNatives_nativeUpCall));
   jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 10);
   EXPECT_EQ(10+9+8+7+6+5+4+3+2+1, result);
@@ -581,8 +622,7 @@
 }
 
 TEST_F(JniCompilerTest, ReturnGlobalRef) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooO", "(Ljava/lang/Object;)Ljava/lang/Object;",
+  SetUpForTest(false, "fooO", "(Ljava/lang/Object;)Ljava/lang/Object;",
                reinterpret_cast<void*>(&Java_MyClassNatives_fooO));
   jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, jobj_);
   EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(result));
@@ -591,16 +631,15 @@
 
 jint local_ref_test(JNIEnv* env, jobject thisObj, jint x) {
   // Add 10 local references
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   for (int i = 0; i < 10; i++) {
-    ts.AddLocalReference<jobject>(ts.Decode<Object*>(thisObj));
+    soa.AddLocalReference<jobject>(soa.Decode<Object*>(thisObj));
   }
   return x+1;
 }
 
 TEST_F(JniCompilerTest, LocalReferenceTableClearingTest) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "fooI", "(I)I", reinterpret_cast<void*>(&local_ref_test));
+  SetUpForTest(false, "fooI", "(I)I", reinterpret_cast<void*>(&local_ref_test));
   // 1000 invocations of a method that adds 10 local references
   for (int i = 0; i < 1000; i++) {
     jint result = env_->CallIntMethod(jobj_, jmethod_, i);
@@ -618,8 +657,7 @@
 }
 
 TEST_F(JniCompilerTest, JavaLangSystemArrayCopy) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+  SetUpForTest(true, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V",
                reinterpret_cast<void*>(&my_arraycopy));
   env_->CallStaticVoidMethod(jklass_, jmethod_, jobj_, 1234, jklass_, 5678, 9876);
 }
@@ -634,8 +672,7 @@
 }
 
 TEST_F(JniCompilerTest, CompareAndSwapInt) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z",
+  SetUpForTest(false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z",
                reinterpret_cast<void*>(&my_casi));
   jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, 0x12345678ABCDEF88ll, 0xCAFEF00D, 0xEBADF00D);
   EXPECT_EQ(result, JNI_TRUE);
@@ -651,8 +688,7 @@
 }
 
 TEST_F(JniCompilerTest, GetText) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I",
+  SetUpForTest(true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I",
                reinterpret_cast<void*>(&my_gettext));
   jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 0x12345678ABCDEF88ll, jobj_,
                                           0x7FEDCBA987654321ll, jobj_);
@@ -670,8 +706,7 @@
 }
 
 TEST_F(JniCompilerTest, UpcallReturnTypeChecking_Instance) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "instanceMethodThatShouldReturnClass", "()Ljava/lang/Class;",
+  SetUpForTest(false, "instanceMethodThatShouldReturnClass", "()Ljava/lang/Class;",
                reinterpret_cast<void*>(&Java_MyClassNatives_instanceMethodThatShouldReturnClass));
 
   CheckJniAbortCatcher check_jni_abort_catcher;
@@ -688,8 +723,7 @@
 }
 
 TEST_F(JniCompilerTest, UpcallReturnTypeChecking_Static) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "staticMethodThatShouldReturnClass", "()Ljava/lang/Class;",
+  SetUpForTest(true, "staticMethodThatShouldReturnClass", "()Ljava/lang/Class;",
                reinterpret_cast<void*>(&Java_MyClassNatives_staticMethodThatShouldReturnClass));
 
   CheckJniAbortCatcher check_jni_abort_catcher;
@@ -714,8 +748,7 @@
 }
 
 TEST_F(JniCompilerTest, UpcallArgumentTypeChecking_Instance) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), false, "instanceMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
+  SetUpForTest(false, "instanceMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
                reinterpret_cast<void*>(&Java_MyClassNatives_instanceMethodThatShouldTakeClass));
 
   CheckJniAbortCatcher check_jni_abort_catcher;
@@ -725,8 +758,7 @@
 }
 
 TEST_F(JniCompilerTest, UpcallArgumentTypeChecking_Static) {
-  SirtRef<ClassLoader> class_loader(LoadDex("MyClassNatives"));
-  SetUpForTest(class_loader.get(), true, "staticMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
+  SetUpForTest(true, "staticMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
                reinterpret_cast<void*>(&Java_MyClassNatives_staticMethodThatShouldTakeClass));
 
   CheckJniAbortCatcher check_jni_abort_catcher;
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 74b740a..dbdc149 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -26,11 +26,12 @@
 #include "class_loader.h"
 #include "jni.h"
 #include "logging.h"
+#include "mutex.h"
 #include "object.h"
 #include "object_utils.h"
 #include "runtime.h"
 #include "safe_map.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
 #include "stl_util.h"
 #include "stringpiece.h"
@@ -55,7 +56,8 @@
 static const size_t kWeakGlobalsInitial = 16; // Arbitrary.
 static const size_t kWeakGlobalsMax = 51200; // Arbitrary sanity check.
 
-void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINativeMethod* methods, size_t method_count) {
+void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINativeMethod* methods,
+                           size_t method_count) {
   ScopedLocalRef<jclass> c(env, env->FindClass(jni_class_name));
   if (c.get() == NULL) {
     LOG(FATAL) << "Couldn't find class: " << jni_class_name;
@@ -91,7 +93,7 @@
 
 class ArgArray {
  public:
-  explicit ArgArray(Method* method) {
+  explicit ArgArray(Method* method) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     MethodHelper mh(method);
     shorty_ = mh.GetShorty();
     shorty_len_ = mh.GetShortyLength();
@@ -107,7 +109,8 @@
     return arg_array_;
   }
 
-  void BuildArgArray(const ScopedJniThreadState& ts, va_list ap) {
+  void BuildArgArray(const ScopedObjectAccess& soa, va_list ap)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     for (size_t i = 1, offset = 0; i < shorty_len_; ++i, ++offset) {
       switch (shorty_[i]) {
         case 'Z':
@@ -129,7 +132,7 @@
           arg_array_[offset].SetF(va_arg(ap, jdouble));
           break;
         case 'L':
-          arg_array_[offset].SetL(ts.Decode<Object*>(va_arg(ap, jobject)));
+          arg_array_[offset].SetL(soa.Decode<Object*>(va_arg(ap, jobject)));
           break;
         case 'D':
           arg_array_[offset].SetD(va_arg(ap, jdouble));
@@ -141,7 +144,8 @@
     }
   }
 
-  void BuildArgArray(const ScopedJniThreadState& ts, jvalue* args) {
+  void BuildArgArray(const ScopedObjectAccess& soa, jvalue* args)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     for (size_t i = 1, offset = 0; i < shorty_len_; ++i, ++offset) {
       switch (shorty_[i]) {
         case 'Z':
@@ -163,7 +167,7 @@
           arg_array_[offset].SetF(args[offset].f);
           break;
         case 'L':
-          arg_array_[offset].SetL(ts.Decode<Object*>(args[offset].l));
+          arg_array_[offset].SetL(soa.Decode<Object*>(args[offset].l));
           break;
         case 'D':
           arg_array_[offset].SetD(args[offset].d);
@@ -184,18 +188,20 @@
   UniquePtr<JValue[]> large_arg_array_;
 };
 
-static jweak AddWeakGlobalReference(ScopedJniThreadState& ts, Object* obj) {
+static jweak AddWeakGlobalReference(ScopedObjectAccess& soa, Object* obj)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (obj == NULL) {
     return NULL;
   }
-  JavaVMExt* vm = ts.Vm();
+  JavaVMExt* vm = soa.Vm();
   IndirectReferenceTable& weak_globals = vm->weak_globals;
   MutexLock mu(vm->weak_globals_lock);
   IndirectRef ref = weak_globals.Add(IRT_FIRST_SEGMENT, obj);
   return reinterpret_cast<jweak>(ref);
 }
 
-static void CheckMethodArguments(Method* m, JValue* args) {
+static void CheckMethodArguments(Method* m, JValue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   MethodHelper mh(m);
   ObjectArray<Class>* parameter_types = mh.GetParameterTypes();
   CHECK(parameter_types != NULL);
@@ -219,45 +225,50 @@
   }
 }
 
-static JValue InvokeWithArgArray(const ScopedJniThreadState& ts, Object* receiver, Method* method,
-                                 JValue* args) {
-  if (UNLIKELY(ts.Env()->check_jni)) {
+static JValue InvokeWithArgArray(const ScopedObjectAccess& soa, Object* receiver,
+                                 Method* method, JValue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (UNLIKELY(soa.Env()->check_jni)) {
     CheckMethodArguments(method, args);
   }
   JValue result;
-  method->Invoke(ts.Self(), receiver, args, &result);
+  method->Invoke(soa.Self(), receiver, args, &result);
   return result;
 }
 
-static JValue InvokeWithVarArgs(const ScopedJniThreadState& ts, jobject obj, jmethodID mid,
-                                va_list args) {
-  Object* receiver = ts.Decode<Object*>(obj);
-  Method* method = ts.DecodeMethod(mid);
+static JValue InvokeWithVarArgs(const ScopedObjectAccess& soa, jobject obj,
+                                jmethodID mid, va_list args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Object* receiver = soa.Decode<Object*>(obj);
+  Method* method = soa.DecodeMethod(mid);
   ArgArray arg_array(method);
-  arg_array.BuildArgArray(ts, args);
-  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+  arg_array.BuildArgArray(soa, args);
+  return InvokeWithArgArray(soa, receiver, method, arg_array.get());
 }
 
-static Method* FindVirtualMethod(Object* receiver, Method* method) {
+static Method* FindVirtualMethod(Object* receiver, Method* method)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(method);
 }
 
-static JValue InvokeVirtualOrInterfaceWithJValues(const ScopedJniThreadState& ts, jobject obj,
-                                                  jmethodID mid, jvalue* args) {
-  Object* receiver = ts.Decode<Object*>(obj);
-  Method* method = FindVirtualMethod(receiver, ts.DecodeMethod(mid));
+static JValue InvokeVirtualOrInterfaceWithJValues(const ScopedObjectAccess& soa,
+                                                  jobject obj, jmethodID mid, jvalue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Object* receiver = soa.Decode<Object*>(obj);
+  Method* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
   ArgArray arg_array(method);
-  arg_array.BuildArgArray(ts, args);
-  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+  arg_array.BuildArgArray(soa, args);
+  return InvokeWithArgArray(soa, receiver, method, arg_array.get());
 }
 
-static JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedJniThreadState& ts, jobject obj,
-                                                  jmethodID mid, va_list args) {
-  Object* receiver = ts.Decode<Object*>(obj);
-  Method* method = FindVirtualMethod(receiver, ts.DecodeMethod(mid));
+static JValue InvokeVirtualOrInterfaceWithVarArgs(const ScopedObjectAccess& soa,
+                                                  jobject obj, jmethodID mid, va_list args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Object* receiver = soa.Decode<Object*>(obj);
+  Method* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
   ArgArray arg_array(method);
-  arg_array.BuildArgArray(ts, args);
-  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+  arg_array.BuildArgArray(soa, args);
+  return InvokeWithArgArray(soa, receiver, method, arg_array.get());
 }
 
 // Section 12.3.2 of the JNI spec describes JNI class descriptors. They're
@@ -284,13 +295,17 @@
   return result;
 }
 
-static void ThrowNoSuchMethodError(ScopedJniThreadState& ts, Class* c, const char* name, const char* sig, const char* kind) {
-  ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
+static void ThrowNoSuchMethodError(ScopedObjectAccess& soa, Class* c,
+                                   const char* name, const char* sig, const char* kind)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
       "no %s method \"%s.%s%s\"", kind, ClassHelper(c).GetDescriptor(), name, sig);
 }
 
-static jmethodID FindMethodID(ScopedJniThreadState& ts, jclass jni_class, const char* name, const char* sig, bool is_static) {
-  Class* c = ts.Decode<Class*>(jni_class);
+static jmethodID FindMethodID(ScopedObjectAccess& soa, jclass jni_class,
+                              const char* name, const char* sig, bool is_static)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Class* c = soa.Decode<Class*>(jni_class);
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
     return NULL;
   }
@@ -308,14 +323,15 @@
   }
 
   if (method == NULL || method->IsStatic() != is_static) {
-    ThrowNoSuchMethodError(ts, c, name, sig, is_static ? "static" : "non-static");
+    ThrowNoSuchMethodError(soa, c, name, sig, is_static ? "static" : "non-static");
     return NULL;
   }
 
-  return ts.EncodeMethod(method);
+  return soa.EncodeMethod(method);
 }
 
-static ClassLoader* GetClassLoader(Thread* self) {
+static ClassLoader* GetClassLoader(Thread* self)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Method* method = self->GetCurrentMethod();
   if (method == NULL || PrettyMethod(method, false) == "java.lang.Runtime.nativeLoad") {
     return self->GetClassLoaderOverride();
@@ -323,9 +339,10 @@
   return method->GetDeclaringClass()->GetClassLoader();
 }
 
-static jfieldID FindFieldID(const ScopedJniThreadState& ts, jclass jni_class, const char* name,
-                            const char* sig, bool is_static) {
-  Class* c = ts.Decode<Class*>(jni_class);
+static jfieldID FindFieldID(const ScopedObjectAccess& soa, jclass jni_class, const char* name,
+                            const char* sig, bool is_static)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Class* c = soa.Decode<Class*>(jni_class);
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
     return NULL;
   }
@@ -334,16 +351,16 @@
   Class* field_type;
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   if (sig[1] != '\0') {
-    ClassLoader* cl = GetClassLoader(ts.Self());
+    ClassLoader* cl = GetClassLoader(soa.Self());
     field_type = class_linker->FindClass(sig, cl);
   } else {
     field_type = class_linker->FindPrimitiveClass(*sig);
   }
   if (field_type == NULL) {
     // Failed to find type from the signature of the field.
-    DCHECK(ts.Self()->IsExceptionPending());
-    ts.Self()->ClearException();
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
+    DCHECK(soa.Self()->IsExceptionPending());
+    soa.Self()->ClearException();
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
         "no type \"%s\" found and so no field \"%s\" could be found in class "
         "\"%s\" or its superclasses", sig, name, ClassHelper(c).GetDescriptor());
     return NULL;
@@ -354,125 +371,85 @@
     field = c->FindInstanceField(name, ClassHelper(field_type).GetDescriptor());
   }
   if (field == NULL) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
         "no \"%s\" field \"%s\" in class \"%s\" or its superclasses", sig,
         name, ClassHelper(c).GetDescriptor());
     return NULL;
   }
-  return ts.EncodeField(field);
+  return soa.EncodeField(field);
 }
 
-static void PinPrimitiveArray(const ScopedJniThreadState& ts, const Array* array) {
-  JavaVMExt* vm = ts.Vm();
+static void PinPrimitiveArray(const ScopedObjectAccess& soa, const Array* array)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  JavaVMExt* vm = soa.Vm();
   MutexLock mu(vm->pins_lock);
   vm->pin_table.Add(array);
 }
 
-static void UnpinPrimitiveArray(const ScopedJniThreadState& ts, const Array* array) {
-  JavaVMExt* vm = ts.Vm();
+static void UnpinPrimitiveArray(const ScopedObjectAccess& soa, const Array* array)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  JavaVMExt* vm = soa.Vm();
   MutexLock mu(vm->pins_lock);
   vm->pin_table.Remove(array);
 }
 
-template<typename JniT, typename ArtT>
-static JniT NewPrimitiveArray(const ScopedJniThreadState& ts, jsize length) {
-  CHECK_GE(length, 0); // TODO: ReportJniError
-  ArtT* result = ArtT::Alloc(length);
-  return ts.AddLocalReference<JniT>(result);
-}
-
-template <typename ArrayT, typename CArrayT, typename ArtArrayT>
-static CArrayT GetPrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jboolean* is_copy) {
-  ArtArrayT* array = ts.Decode<ArtArrayT*>(java_array);
-  PinPrimitiveArray(ts, array);
-  if (is_copy != NULL) {
-    *is_copy = JNI_FALSE;
-  }
-  return array->GetData();
-}
-
-template <typename ArrayT>
-static void ReleasePrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jint mode) {
-  if (mode != JNI_COMMIT) {
-    Array* array = ts.Decode<Array*>(java_array);
-    UnpinPrimitiveArray(ts, array);
-  }
-}
-
-static void ThrowAIOOBE(ScopedJniThreadState& ts, Array* array, jsize start, jsize length, const char* identifier) {
+static void ThrowAIOOBE(ScopedObjectAccess& soa, Array* array, jsize start,
+                        jsize length, const char* identifier)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::string type(PrettyTypeOf(array));
-  ts.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
+  soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
       "%s offset=%d length=%d %s.length=%d",
       type.c_str(), start, length, identifier, array->GetLength());
 }
 
-static void ThrowSIOOBE(ScopedJniThreadState& ts, jsize start, jsize length, jsize array_length) {
-  ts.Self()->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
+static void ThrowSIOOBE(ScopedObjectAccess& soa, jsize start, jsize length,
+                        jsize array_length)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  soa.Self()->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
       "offset=%d length=%d string.length()=%d", start, length, array_length);
 }
 
-template <typename JavaArrayT, typename JavaT, typename ArrayT>
-static void GetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, JavaT* buf) {
-  ArrayT* array = ts.Decode<ArrayT*>(java_array);
-  if (start < 0 || length < 0 || start + length > array->GetLength()) {
-    ThrowAIOOBE(ts, array, start, length, "src");
-  } else {
-    JavaT* data = array->GetData();
-    memcpy(buf, data + start, length * sizeof(JavaT));
+int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause)
+    LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
+  ScopedObjectAccess soa(env);
+
+  // Turn the const char* into a java.lang.String.
+  ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg));
+  if (msg != NULL && s.get() == NULL) {
+    return JNI_ERR;
   }
-}
 
-template <typename JavaArrayT, typename JavaT, typename ArrayT>
-static void SetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, const JavaT* buf) {
-  ArrayT* array = ts.Decode<ArrayT*>(java_array);
-  if (start < 0 || length < 0 || start + length > array->GetLength()) {
-    ThrowAIOOBE(ts, array, start, length, "dst");
+  // Choose an appropriate constructor and set up the arguments.
+  jvalue args[2];
+  const char* signature;
+  if (msg == NULL && cause == NULL) {
+    signature = "()V";
+  } else if (msg != NULL && cause == NULL) {
+    signature = "(Ljava/lang/String;)V";
+    args[0].l = s.get();
+  } else if (msg == NULL && cause != NULL) {
+    signature = "(Ljava/lang/Throwable;)V";
+    args[0].l = cause;
   } else {
-    JavaT* data = array->GetData();
-    memcpy(data + start, buf, length * sizeof(JavaT));
+    signature = "(Ljava/lang/String;Ljava/lang/Throwable;)V";
+    args[0].l = s.get();
+    args[1].l = cause;
   }
-}
+  jmethodID mid = env->GetMethodID(exception_class, "<init>", signature);
+  if (mid == NULL) {
+    LOG(ERROR) << "No <init>" << signature << " in "
+        << PrettyClass(soa.Decode<Class*>(exception_class));
+    return JNI_ERR;
+  }
 
-int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause) {
-    ScopedJniThreadState ts(env);
+  ScopedLocalRef<jthrowable> exception(env, reinterpret_cast<jthrowable>(env->NewObjectA(exception_class, mid, args)));
+  if (exception.get() == NULL) {
+    return JNI_ERR;
+  }
 
-    // Turn the const char* into a java.lang.String.
-    ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg));
-    if (msg != NULL && s.get() == NULL) {
-      return JNI_ERR;
-    }
+  soa.Self()->SetException(soa.Decode<Throwable*>(exception.get()));
 
-    // Choose an appropriate constructor and set up the arguments.
-    jvalue args[2];
-    const char* signature;
-    if (msg == NULL && cause == NULL) {
-      signature = "()V";
-    } else if (msg != NULL && cause == NULL) {
-      signature = "(Ljava/lang/String;)V";
-      args[0].l = s.get();
-    } else if (msg == NULL && cause != NULL) {
-      signature = "(Ljava/lang/Throwable;)V";
-      args[0].l = cause;
-    } else {
-      signature = "(Ljava/lang/String;Ljava/lang/Throwable;)V";
-      args[0].l = s.get();
-      args[1].l = cause;
-    }
-    jmethodID mid = env->GetMethodID(exception_class, "<init>", signature);
-    if (mid == NULL) {
-      LOG(ERROR) << "No <init>" << signature << " in "
-          << PrettyClass(ts.Decode<Class*>(exception_class));
-      return JNI_ERR;
-    }
-
-    ScopedLocalRef<jthrowable> exception(env, reinterpret_cast<jthrowable>(env->NewObjectA(exception_class, mid, args)));
-    if (exception.get() == NULL) {
-      return JNI_ERR;
-    }
-
-    ts.Self()->SetException(ts.Decode<Throwable*>(exception.get()));
-
-    return JNI_OK;
+  return JNI_OK;
 }
 
 static jint JII_AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* raw_args, bool as_daemon) {
@@ -533,32 +510,36 @@
    * Check the result of an earlier call to JNI_OnLoad on this library.
    * If the call has not yet finished in another thread, wait for it.
    */
-  bool CheckOnLoadResult() {
-    MutexLock mu(jni_on_load_lock_);
-
+  bool CheckOnLoadResult()
+      LOCKS_EXCLUDED(jni_on_load_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Thread* self = Thread::Current();
-    if (jni_on_load_thread_id_ == self->GetThinLockId()) {
-      // Check this so we don't end up waiting for ourselves.  We need
-      // to return "true" so the caller can continue.
-      LOG(INFO) << *self << " recursive attempt to load library "
-                << "\"" << path_ << "\"";
-      return true;
-    }
+    self->TransitionFromRunnableToSuspended(kWaitingForJniOnLoad);
+    bool okay;
+    {
+      MutexLock mu(jni_on_load_lock_);
 
-    while (jni_on_load_result_ == kPending) {
-      VLOG(jni) << "[" << *self << " waiting for \"" << path_ << "\" "
-                << "JNI_OnLoad...]";
-      ScopedThreadStateChange tsc(self, kVmWait);
-      jni_on_load_cond_.Wait(jni_on_load_lock_);
-    }
+      if (jni_on_load_thread_id_ == self->GetThinLockId()) {
+        // Check this so we don't end up waiting for ourselves.  We need to return "true" so the
+        // caller can continue.
+        LOG(INFO) << *self << " recursive attempt to load library " << "\"" << path_ << "\"";
+        okay = true;
+      } else {
+        while (jni_on_load_result_ == kPending) {
+          VLOG(jni) << "[" << *self << " waiting for \"" << path_ << "\" " << "JNI_OnLoad...]";
+          jni_on_load_cond_.Wait(jni_on_load_lock_);
+        }
 
-    bool okay = (jni_on_load_result_ == kOkay);
-    VLOG(jni) << "[Earlier JNI_OnLoad for \"" << path_ << "\" "
-              << (okay ? "succeeded" : "failed") << "]";
+        okay = (jni_on_load_result_ == kOkay);
+        VLOG(jni) << "[Earlier JNI_OnLoad for \"" << path_ << "\" "
+            << (okay ? "succeeded" : "failed") << "]";
+      }
+    }
+    self->TransitionFromSuspendedToRunnable();
     return okay;
   }
 
-  void SetResult(bool result) {
+  void SetResult(bool result) LOCKS_EXCLUDED(jni_on_load_lock_) {
     MutexLock mu(jni_on_load_lock_);
 
     jni_on_load_result_ = result ? kOkay : kFailed;
@@ -589,7 +570,7 @@
   Object* class_loader_;
 
   // Guards remaining items.
-  Mutex jni_on_load_lock_;
+  Mutex jni_on_load_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   // Wait for JNI_OnLoad in other thread.
   ConditionVariable jni_on_load_cond_;
   // Recursive invocation guard.
@@ -633,7 +614,8 @@
   }
 
   // See section 11.3 "Linking Native Methods" of the JNI spec.
-  void* FindNativeMethod(const Method* m, std::string& detail) {
+  void* FindNativeMethod(const Method* m, std::string& detail)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::string jni_short_name(JniShortName(m));
     std::string jni_long_name(JniLongName(m));
     const ClassLoader* declaring_class_loader = m->GetDeclaringClass()->GetClassLoader();
@@ -667,109 +649,112 @@
   SafeMap<std::string, SharedLibrary*> libraries_;
 };
 
-JValue InvokeWithJValues(const ScopedJniThreadState& ts, jobject obj, jmethodID mid, jvalue* args) {
-  Object* receiver = ts.Decode<Object*>(obj);
-  Method* method = ts.DecodeMethod(mid);
+JValue InvokeWithJValues(const ScopedObjectAccess& soa, jobject obj, jmethodID mid,
+                         jvalue* args) {
+  Object* receiver = soa.Decode<Object*>(obj);
+  Method* method = soa.DecodeMethod(mid);
   ArgArray arg_array(method);
-  arg_array.BuildArgArray(ts, args);
-  return InvokeWithArgArray(ts, receiver, method, arg_array.get());
+  arg_array.BuildArgArray(soa, args);
+  return InvokeWithArgArray(soa, receiver, method, arg_array.get());
 }
 
-JValue InvokeWithJValues(const ScopedJniThreadState& ts, Object* receiver, Method* m, JValue* args) {
-  return InvokeWithArgArray(ts, receiver, m, args);
+JValue InvokeWithJValues(const ScopedObjectAccess& soa, Object* receiver, Method* m,
+                         JValue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  return InvokeWithArgArray(soa, receiver, m, args);
 }
 
 class JNI {
  public:
   static jint GetVersion(JNIEnv* env) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     return JNI_VERSION_1_6;
   }
 
   static jclass DefineClass(JNIEnv* env, const char*, jobject, const jbyte*, jsize) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     LOG(WARNING) << "JNI DefineClass is not supported";
     return NULL;
   }
 
   static jclass FindClass(JNIEnv* env, const char* name) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     Runtime* runtime = Runtime::Current();
     ClassLinker* class_linker = runtime->GetClassLinker();
     std::string descriptor(NormalizeJniClassDescriptor(name));
     Class* c = NULL;
     if (runtime->IsStarted()) {
-      ClassLoader* cl = GetClassLoader(ts.Self());
+      ClassLoader* cl = GetClassLoader(soa.Self());
       c = class_linker->FindClass(descriptor.c_str(), cl);
     } else {
       c = class_linker->FindSystemClass(descriptor.c_str());
     }
-    return ts.AddLocalReference<jclass>(c);
+    return soa.AddLocalReference<jclass>(c);
   }
 
   static jmethodID FromReflectedMethod(JNIEnv* env, jobject java_method) {
-    ScopedJniThreadState ts(env);
-    Method* method = ts.Decode<Method*>(java_method);
-    return ts.EncodeMethod(method);
+    ScopedObjectAccess soa(env);
+    Method* method = soa.Decode<Method*>(java_method);
+    return soa.EncodeMethod(method);
   }
 
   static jfieldID FromReflectedField(JNIEnv* env, jobject java_field) {
-    ScopedJniThreadState ts(env);
-    Field* field = ts.Decode<Field*>(java_field);
-    return ts.EncodeField(field);
+    ScopedObjectAccess soa(env);
+    Field* field = soa.Decode<Field*>(java_field);
+    return soa.EncodeField(field);
   }
 
   static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
-    ScopedJniThreadState ts(env);
-    Method* method = ts.DecodeMethod(mid);
-    return ts.AddLocalReference<jobject>(method);
+    ScopedObjectAccess soa(env);
+    Method* method = soa.DecodeMethod(mid);
+    return soa.AddLocalReference<jobject>(method);
   }
 
   static jobject ToReflectedField(JNIEnv* env, jclass, jfieldID fid, jboolean) {
-    ScopedJniThreadState ts(env);
-    Field* field = ts.DecodeField(fid);
-    return ts.AddLocalReference<jobject>(field);
+    ScopedObjectAccess soa(env);
+    Field* field = soa.DecodeField(fid);
+    return soa.AddLocalReference<jobject>(field);
   }
 
   static jclass GetObjectClass(JNIEnv* env, jobject java_object) {
-    ScopedJniThreadState ts(env);
-    Object* o = ts.Decode<Object*>(java_object);
-    return ts.AddLocalReference<jclass>(o->GetClass());
+    ScopedObjectAccess soa(env);
+    Object* o = soa.Decode<Object*>(java_object);
+    return soa.AddLocalReference<jclass>(o->GetClass());
   }
 
   static jclass GetSuperclass(JNIEnv* env, jclass java_class) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
-    return ts.AddLocalReference<jclass>(c->GetSuperClass());
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
+    return soa.AddLocalReference<jclass>(c->GetSuperClass());
   }
 
   static jboolean IsAssignableFrom(JNIEnv* env, jclass java_class1, jclass java_class2) {
-    ScopedJniThreadState ts(env);
-    Class* c1 = ts.Decode<Class*>(java_class1);
-    Class* c2 = ts.Decode<Class*>(java_class2);
+    ScopedObjectAccess soa(env);
+    Class* c1 = soa.Decode<Class*>(java_class1);
+    Class* c2 = soa.Decode<Class*>(java_class2);
     return c1->IsAssignableFrom(c2) ? JNI_TRUE : JNI_FALSE;
   }
 
   static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass java_class) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     CHECK_NE(static_cast<jclass>(NULL), java_class); // TODO: ReportJniError
     if (jobj == NULL) {
       // Note: JNI is different from regular Java instanceof in this respect
       return JNI_TRUE;
     } else {
-      Object* obj = ts.Decode<Object*>(jobj);
-      Class* c = ts.Decode<Class*>(java_class);
+      Object* obj = soa.Decode<Object*>(jobj);
+      Class* c = soa.Decode<Class*>(java_class);
       return obj->InstanceOf(c) ? JNI_TRUE : JNI_FALSE;
     }
   }
 
   static jint Throw(JNIEnv* env, jthrowable java_exception) {
-    ScopedJniThreadState ts(env);
-    Throwable* exception = ts.Decode<Throwable*>(java_exception);
+    ScopedObjectAccess soa(env);
+    Throwable* exception = soa.Decode<Throwable*>(java_exception);
     if (exception == NULL) {
       return JNI_ERR;
     }
-    ts.Self()->SetException(exception);
+    soa.Self()->SetException(exception);
     return JNI_OK;
   }
 
@@ -778,23 +763,23 @@
   }
 
   static jboolean ExceptionCheck(JNIEnv* env) {
-    ScopedJniThreadState ts(env);
-    return ts.Self()->IsExceptionPending() ? JNI_TRUE : JNI_FALSE;
+    ScopedObjectAccess soa(env);
+    return soa.Self()->IsExceptionPending() ? JNI_TRUE : JNI_FALSE;
   }
 
   static void ExceptionClear(JNIEnv* env) {
-    ScopedJniThreadState ts(env);
-    ts.Self()->ClearException();
+    ScopedObjectAccess soa(env);
+    soa.Self()->ClearException();
   }
 
   static void ExceptionDescribe(JNIEnv* env) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
 
-    Thread* self = ts.Self();
+    Thread* self = soa.Self();
     Throwable* original_exception = self->GetException();
     self->ClearException();
 
-    ScopedLocalRef<jthrowable> exception(env, ts.AddLocalReference<jthrowable>(original_exception));
+    ScopedLocalRef<jthrowable> exception(env, soa.AddLocalReference<jthrowable>(original_exception));
     ScopedLocalRef<jclass> exception_class(env, env->GetObjectClass(exception.get()));
     jmethodID mid = env->GetMethodID(exception_class.get(), "printStackTrace", "()V");
     if (mid == NULL) {
@@ -813,72 +798,58 @@
   }
 
   static jthrowable ExceptionOccurred(JNIEnv* env) {
-    ScopedJniThreadState ts(env);
-    Object* exception = ts.Self()->GetException();
-    return ts.AddLocalReference<jthrowable>(exception);
+    ScopedObjectAccess soa(env);
+    Object* exception = soa.Self()->GetException();
+    return soa.AddLocalReference<jthrowable>(exception);
   }
 
   static void FatalError(JNIEnv* env, const char* msg) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     LOG(FATAL) << "JNI FatalError called: " << msg;
   }
 
   static jint PushLocalFrame(JNIEnv* env, jint capacity) {
-    ScopedJniThreadState ts(env);
-    if (EnsureLocalCapacity(ts, capacity, "PushLocalFrame") != JNI_OK) {
+    ScopedObjectAccess soa(env);
+    if (EnsureLocalCapacity(soa, capacity, "PushLocalFrame") != JNI_OK) {
       return JNI_ERR;
     }
-    ts.Env()->PushFrame(capacity);
+    soa.Env()->PushFrame(capacity);
     return JNI_OK;
   }
 
   static jobject PopLocalFrame(JNIEnv* env, jobject java_survivor) {
-    ScopedJniThreadState ts(env);
-    Object* survivor = ts.Decode<Object*>(java_survivor);
-    ts.Env()->PopFrame();
-    return ts.AddLocalReference<jobject>(survivor);
+    ScopedObjectAccess soa(env);
+    Object* survivor = soa.Decode<Object*>(java_survivor);
+    soa.Env()->PopFrame();
+    return soa.AddLocalReference<jobject>(survivor);
   }
 
   static jint EnsureLocalCapacity(JNIEnv* env, jint desired_capacity) {
-    ScopedJniThreadState ts(env);
-    return EnsureLocalCapacity(ts, desired_capacity, "EnsureLocalCapacity");
-  }
-
-  static jint EnsureLocalCapacity(const ScopedJniThreadState& ts, jint desired_capacity, const char* caller) {
-    // TODO: we should try to expand the table if necessary.
-    if (desired_capacity < 1 || desired_capacity > static_cast<jint>(kLocalsMax)) {
-      LOG(ERROR) << "Invalid capacity given to " << caller << ": " << desired_capacity;
-      return JNI_ERR;
-    }
-    // TODO: this isn't quite right, since "capacity" includes holes.
-    size_t capacity = ts.Env()->locals.Capacity();
-    bool okay = (static_cast<jint>(kLocalsMax - capacity) >= desired_capacity);
-    if (!okay) {
-      ts.Self()->ThrowOutOfMemoryError(caller);
-    }
-    return okay ? JNI_OK : JNI_ERR;
+    ScopedObjectAccess soa(env);
+    return EnsureLocalCapacity(soa, desired_capacity, "EnsureLocalCapacity");
   }
 
   static jobject NewGlobalRef(JNIEnv* env, jobject obj) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (obj == NULL) {
       return NULL;
     }
 
-    JavaVMExt* vm = ts.Vm();
+    JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& globals = vm->globals;
+    Object* decoded_obj = soa.Decode<Object*>(obj);
     MutexLock mu(vm->globals_lock);
-    IndirectRef ref = globals.Add(IRT_FIRST_SEGMENT, ts.Decode<Object*>(obj));
+    IndirectRef ref = globals.Add(IRT_FIRST_SEGMENT, decoded_obj);
     return reinterpret_cast<jobject>(ref);
   }
 
   static void DeleteGlobalRef(JNIEnv* env, jobject obj) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (obj == NULL) {
       return;
     }
 
-    JavaVMExt* vm = ts.Vm();
+    JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& globals = vm->globals;
     MutexLock mu(vm->globals_lock);
 
@@ -889,17 +860,17 @@
   }
 
   static jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) {
-    ScopedJniThreadState ts(env);
-    return AddWeakGlobalReference(ts, ts.Decode<Object*>(obj));
+    ScopedObjectAccess soa(env);
+    return AddWeakGlobalReference(soa, soa.Decode<Object*>(obj));
   }
 
   static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (obj == NULL) {
       return;
     }
 
-    JavaVMExt* vm = ts.Vm();
+    JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& weak_globals = vm->weak_globals;
     MutexLock mu(vm->weak_globals_lock);
 
@@ -910,27 +881,27 @@
   }
 
   static jobject NewLocalRef(JNIEnv* env, jobject obj) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (obj == NULL) {
       return NULL;
     }
 
-    IndirectReferenceTable& locals = ts.Env()->locals;
+    IndirectReferenceTable& locals = soa.Env()->locals;
 
-    uint32_t cookie = ts.Env()->local_ref_cookie;
-    IndirectRef ref = locals.Add(cookie, ts.Decode<Object*>(obj));
+    uint32_t cookie = soa.Env()->local_ref_cookie;
+    IndirectRef ref = locals.Add(cookie, soa.Decode<Object*>(obj));
     return reinterpret_cast<jobject>(ref);
   }
 
   static void DeleteLocalRef(JNIEnv* env, jobject obj) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (obj == NULL) {
       return;
     }
 
-    IndirectReferenceTable& locals = ts.Env()->locals;
+    IndirectReferenceTable& locals = soa.Env()->locals;
 
-    uint32_t cookie = ts.Env()->local_ref_cookie;
+    uint32_t cookie = soa.Env()->local_ref_cookie;
     if (!locals.Remove(cookie, obj)) {
       // Attempting to delete a local reference that is not in the
       // topmost local reference frame is a no-op.  DeleteLocalRef returns
@@ -943,22 +914,22 @@
   }
 
   static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
-    ScopedJniThreadState ts(env);
-    return (ts.Decode<Object*>(obj1) == ts.Decode<Object*>(obj2))
+    ScopedObjectAccess soa(env);
+    return (soa.Decode<Object*>(obj1) == soa.Decode<Object*>(obj2))
         ? JNI_TRUE : JNI_FALSE;
   }
 
   static jobject AllocObject(JNIEnv* env, jclass java_class) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
-    return ts.AddLocalReference<jobject>(c->AllocObject());
+    return soa.AddLocalReference<jobject>(c->AllocObject());
   }
 
   static jobject NewObject(JNIEnv* env, jclass c, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list args;
     va_start(args, mid);
     jobject result = NewObjectV(env, c, mid, args);
@@ -967,8 +938,8 @@
   }
 
   static jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
@@ -976,9 +947,9 @@
     if (result == NULL) {
       return NULL;
     }
-    jobject local_result = ts.AddLocalReference<jobject>(result);
+    jobject local_result = soa.AddLocalReference<jobject>(result);
     CallNonvirtualVoidMethodV(env, local_result, java_class, mid, args);
-    if (!ts.Self()->IsExceptionPending()) {
+    if (!soa.Self()->IsExceptionPending()) {
       return local_result;
     } else {
       return NULL;
@@ -986,8 +957,8 @@
   }
 
   static jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
@@ -995,9 +966,9 @@
     if (result == NULL) {
       return NULL;
     }
-    jobject local_result = ts.AddLocalReference<jobjectArray>(result);
+    jobject local_result = soa.AddLocalReference<jobjectArray>(result);
     CallNonvirtualVoidMethodA(env, local_result, java_class, mid, args);
-    if (!ts.Self()->IsExceptionPending()) {
+    if (!soa.Self()->IsExceptionPending()) {
       return local_result;
     } else {
       return NULL;
@@ -1005,468 +976,468 @@
   }
 
   static jmethodID GetMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
-    ScopedJniThreadState ts(env);
-    return FindMethodID(ts, c, name, sig, false);
+    ScopedObjectAccess soa(env);
+    return FindMethodID(soa, c, name, sig, false);
   }
 
   static jmethodID GetStaticMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
-    ScopedJniThreadState ts(env);
-    return FindMethodID(ts, c, name, sig, true);
+    ScopedObjectAccess soa(env);
+    return FindMethodID(soa, c, name, sig, true);
   }
 
   static jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
-    return ts.AddLocalReference<jobject>(result.GetL());
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetZ();
   }
 
   static jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetZ();
   }
 
   static jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetZ();
   }
 
   static jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetB();
   }
 
   static jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetB();
   }
 
   static jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetB();
   }
 
   static jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetC();
   }
 
   static jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetC();
   }
 
   static jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetC();
   }
 
   static jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetD();
   }
 
   static jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetD();
   }
 
   static jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetD();
   }
 
   static jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetF();
   }
 
   static jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetF();
   }
 
   static jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetF();
   }
 
   static jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetI();
   }
 
   static jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetI();
   }
 
   static jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetI();
   }
 
   static jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetJ();
   }
 
   static jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetJ();
   }
 
   static jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetJ();
   }
 
   static jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetS();
   }
 
   static jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args).GetS();
   }
 
   static jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args).GetS();
   }
 
   static void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
   }
 
   static void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    InvokeVirtualOrInterfaceWithVarArgs(ts, obj, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeVirtualOrInterfaceWithVarArgs(soa, obj, mid, args);
   }
 
   static void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    InvokeVirtualOrInterfaceWithJValues(ts, obj, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeVirtualOrInterfaceWithJValues(soa, obj, mid, args);
   }
 
   static jobject CallNonvirtualObjectMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
-    jobject local_result = ts.AddLocalReference<jobject>(result.GetL());
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
+    jobject local_result = soa.AddLocalReference<jobject>(result.GetL());
     va_end(ap);
     return local_result;
   }
 
   static jobject CallNonvirtualObjectMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeWithVarArgs(soa, obj, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jobject CallNonvirtualObjectMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeWithJValues(ts, obj, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeWithJValues(soa, obj, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetZ();
   }
 
   static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetZ();
   }
 
   static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetZ();
   }
 
   static jbyte CallNonvirtualByteMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetB();
   }
 
   static jbyte CallNonvirtualByteMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetB();
   }
 
   static jbyte CallNonvirtualByteMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetB();
   }
 
   static jchar CallNonvirtualCharMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetC();
   }
 
   static jchar CallNonvirtualCharMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetC();
   }
 
   static jchar CallNonvirtualCharMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetC();
   }
 
   static jshort CallNonvirtualShortMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetS();
   }
 
   static jshort CallNonvirtualShortMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetS();
   }
 
   static jshort CallNonvirtualShortMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetS();
   }
 
   static jint CallNonvirtualIntMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetI();
   }
 
   static jint CallNonvirtualIntMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetI();
   }
 
   static jint CallNonvirtualIntMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetI();
   }
 
   static jlong CallNonvirtualLongMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetJ();
   }
 
   static jlong CallNonvirtualLongMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetJ();
   }
 
   static jlong CallNonvirtualLongMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetJ();
   }
 
   static jfloat CallNonvirtualFloatMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetF();
   }
 
   static jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetF();
   }
 
   static jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetF();
   }
 
   static jdouble CallNonvirtualDoubleMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, obj, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, obj, mid, ap));
     va_end(ap);
     return result.GetD();
   }
 
   static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, obj, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, obj, mid, args).GetD();
   }
 
   static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, obj, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, obj, mid, args).GetD();
   }
 
   static void CallNonvirtualVoidMethod(JNIEnv* env, jobject obj, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    InvokeWithVarArgs(ts, obj, mid, ap);
+    InvokeWithVarArgs(soa, obj, mid, ap);
     va_end(ap);
   }
 
   static void CallNonvirtualVoidMethodV(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    InvokeWithVarArgs(ts, obj, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeWithVarArgs(soa, obj, mid, args);
   }
 
   static void CallNonvirtualVoidMethodA(JNIEnv* env,
       jobject obj, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    InvokeWithJValues(ts, obj, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeWithJValues(soa, obj, mid, args);
   }
 
   static jfieldID GetFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
-    ScopedJniThreadState ts(env);
-    return FindFieldID(ts, c, name, sig, false);
+    ScopedObjectAccess soa(env);
+    return FindFieldID(soa, c, name, sig, false);
   }
 
 
   static jfieldID GetStaticFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
-    ScopedJniThreadState ts(env);
-    return FindFieldID(ts, c, name, sig, true);
+    ScopedObjectAccess soa(env);
+    return FindFieldID(soa, c, name, sig, true);
   }
 
   static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid) {
-    ScopedJniThreadState ts(env);
-    Object* o = ts.Decode<Object*>(obj);
-    Field* f = ts.DecodeField(fid);
-    return ts.AddLocalReference<jobject>(f->GetObject(o));
+    ScopedObjectAccess soa(env);
+    Object* o = soa.Decode<Object*>(obj);
+    Field* f = soa.DecodeField(fid);
+    return soa.AddLocalReference<jobject>(f->GetObject(o));
   }
 
   static jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid) {
-    ScopedJniThreadState ts(env);
-    Field* f = ts.DecodeField(fid);
-    return ts.AddLocalReference<jobject>(f->GetObject(NULL));
+    ScopedObjectAccess soa(env);
+    Field* f = soa.DecodeField(fid);
+    return soa.AddLocalReference<jobject>(f->GetObject(NULL));
   }
 
   static void SetObjectField(JNIEnv* env, jobject java_object, jfieldID fid, jobject java_value) {
-    ScopedJniThreadState ts(env);
-    Object* o = ts.Decode<Object*>(java_object);
-    Object* v = ts.Decode<Object*>(java_value);
-    Field* f = ts.DecodeField(fid);
+    ScopedObjectAccess soa(env);
+    Object* o = soa.Decode<Object*>(java_object);
+    Object* v = soa.Decode<Object*>(java_value);
+    Field* f = soa.DecodeField(fid);
     f->SetObject(o, v);
   }
 
   static void SetStaticObjectField(JNIEnv* env, jclass, jfieldID fid, jobject java_value) {
-    ScopedJniThreadState ts(env);
-    Object* v = ts.Decode<Object*>(java_value);
-    Field* f = ts.DecodeField(fid);
+    ScopedObjectAccess soa(env);
+    Object* v = soa.Decode<Object*>(java_value);
+    Field* f = soa.DecodeField(fid);
     f->SetObject(NULL, v);
   }
 
 #define GET_PRIMITIVE_FIELD(fn, instance) \
-  ScopedJniThreadState ts(env); \
-  Object* o = ts.Decode<Object*>(instance); \
-  Field* f = ts.DecodeField(fid); \
+  ScopedObjectAccess soa(env); \
+  Object* o = soa.Decode<Object*>(instance); \
+  Field* f = soa.DecodeField(fid); \
   return f->fn(o)
 
 #define SET_PRIMITIVE_FIELD(fn, instance, value) \
-  ScopedJniThreadState ts(env); \
-  Object* o = ts.Decode<Object*>(instance); \
-  Field* f = ts.DecodeField(fid); \
+  ScopedObjectAccess soa(env); \
+  Object* o = soa.Decode<Object*>(instance); \
+  Field* f = soa.DecodeField(fid); \
   f->fn(o, value)
 
   static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid) {
@@ -1598,227 +1569,227 @@
   }
 
   static jobject CallStaticObjectMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
-    jobject local_result = ts.AddLocalReference<jobject>(result.GetL());
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
+    jobject local_result = soa.AddLocalReference<jobject>(result.GetL());
     va_end(ap);
     return local_result;
   }
 
   static jobject CallStaticObjectMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jobject CallStaticObjectMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    JValue result(InvokeWithJValues(ts, NULL, mid, args));
-    return ts.AddLocalReference<jobject>(result.GetL());
+    ScopedObjectAccess soa(env);
+    JValue result(InvokeWithJValues(soa, NULL, mid, args));
+    return soa.AddLocalReference<jobject>(result.GetL());
   }
 
   static jboolean CallStaticBooleanMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetZ();
   }
 
   static jboolean CallStaticBooleanMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetZ();
   }
 
   static jboolean CallStaticBooleanMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetZ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetZ();
   }
 
   static jbyte CallStaticByteMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetB();
   }
 
   static jbyte CallStaticByteMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetB();
   }
 
   static jbyte CallStaticByteMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetB();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetB();
   }
 
   static jchar CallStaticCharMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetC();
   }
 
   static jchar CallStaticCharMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetC();
   }
 
   static jchar CallStaticCharMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetC();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetC();
   }
 
   static jshort CallStaticShortMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetS();
   }
 
   static jshort CallStaticShortMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetS();
   }
 
   static jshort CallStaticShortMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetS();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetS();
   }
 
   static jint CallStaticIntMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetI();
   }
 
   static jint CallStaticIntMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetI();
   }
 
   static jint CallStaticIntMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetI();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetI();
   }
 
   static jlong CallStaticLongMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetJ();
   }
 
   static jlong CallStaticLongMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetJ();
   }
 
   static jlong CallStaticLongMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetJ();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetJ();
   }
 
   static jfloat CallStaticFloatMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetF();
   }
 
   static jfloat CallStaticFloatMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetF();
   }
 
   static jfloat CallStaticFloatMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetF();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetF();
   }
 
   static jdouble CallStaticDoubleMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    JValue result(InvokeWithVarArgs(ts, NULL, mid, ap));
+    JValue result(InvokeWithVarArgs(soa, NULL, mid, ap));
     va_end(ap);
     return result.GetD();
   }
 
   static jdouble CallStaticDoubleMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithVarArgs(ts, NULL, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeWithVarArgs(soa, NULL, mid, args).GetD();
   }
 
   static jdouble CallStaticDoubleMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    return InvokeWithJValues(ts, NULL, mid, args).GetD();
+    ScopedObjectAccess soa(env);
+    return InvokeWithJValues(soa, NULL, mid, args).GetD();
   }
 
   static void CallStaticVoidMethod(JNIEnv* env, jclass, jmethodID mid, ...) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     va_list ap;
     va_start(ap, mid);
-    InvokeWithVarArgs(ts, NULL, mid, ap);
+    InvokeWithVarArgs(soa, NULL, mid, ap);
     va_end(ap);
   }
 
   static void CallStaticVoidMethodV(JNIEnv* env, jclass, jmethodID mid, va_list args) {
-    ScopedJniThreadState ts(env);
-    InvokeWithVarArgs(ts, NULL, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeWithVarArgs(soa, NULL, mid, args);
   }
 
   static void CallStaticVoidMethodA(JNIEnv* env, jclass, jmethodID mid, jvalue* args) {
-    ScopedJniThreadState ts(env);
-    InvokeWithJValues(ts, NULL, mid, args);
+    ScopedObjectAccess soa(env);
+    InvokeWithJValues(soa, NULL, mid, args);
   }
 
   static jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     String* result = String::AllocFromUtf16(char_count, chars);
-    return ts.AddLocalReference<jstring>(result);
+    return soa.AddLocalReference<jstring>(result);
   }
 
   static jstring NewStringUTF(JNIEnv* env, const char* utf) {
     if (utf == NULL) {
       return NULL;
     }
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     String* result = String::AllocFromModifiedUtf8(utf);
-    return ts.AddLocalReference<jstring>(result);
+    return soa.AddLocalReference<jstring>(result);
   }
 
   static jsize GetStringLength(JNIEnv* env, jstring java_string) {
-    ScopedJniThreadState ts(env);
-    return ts.Decode<String*>(java_string)->GetLength();
+    ScopedObjectAccess soa(env);
+    return soa.Decode<String*>(java_string)->GetLength();
   }
 
   static jsize GetStringUTFLength(JNIEnv* env, jstring java_string) {
-    ScopedJniThreadState ts(env);
-    return ts.Decode<String*>(java_string)->GetUtfLength();
+    ScopedObjectAccess soa(env);
+    return soa.Decode<String*>(java_string)->GetUtfLength();
   }
 
   static void GetStringRegion(JNIEnv* env, jstring java_string, jsize start, jsize length, jchar* buf) {
-    ScopedJniThreadState ts(env);
-    String* s = ts.Decode<String*>(java_string);
+    ScopedObjectAccess soa(env);
+    String* s = soa.Decode<String*>(java_string);
     if (start < 0 || length < 0 || start + length > s->GetLength()) {
-      ThrowSIOOBE(ts, start, length, s->GetLength());
+      ThrowSIOOBE(soa, start, length, s->GetLength());
     } else {
       const jchar* chars = s->GetCharArray()->GetData() + s->GetOffset();
       memcpy(buf, chars + start, length * sizeof(jchar));
@@ -1826,10 +1797,10 @@
   }
 
   static void GetStringUTFRegion(JNIEnv* env, jstring java_string, jsize start, jsize length, char* buf) {
-    ScopedJniThreadState ts(env);
-    String* s = ts.Decode<String*>(java_string);
+    ScopedObjectAccess soa(env);
+    String* s = soa.Decode<String*>(java_string);
     if (start < 0 || length < 0 || start + length > s->GetLength()) {
-      ThrowSIOOBE(ts, start, length, s->GetLength());
+      ThrowSIOOBE(soa, start, length, s->GetLength());
     } else {
       const jchar* chars = s->GetCharArray()->GetData() + s->GetOffset();
       ConvertUtf16ToModifiedUtf8(buf, chars + start, length);
@@ -1837,10 +1808,10 @@
   }
 
   static const jchar* GetStringChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    String* s = ts.Decode<String*>(java_string);
+    ScopedObjectAccess soa(env);
+    String* s = soa.Decode<String*>(java_string);
     const CharArray* chars = s->GetCharArray();
-    PinPrimitiveArray(ts, chars);
+    PinPrimitiveArray(soa, chars);
     if (is_copy != NULL) {
       *is_copy = JNI_FALSE;
     }
@@ -1848,29 +1819,29 @@
   }
 
   static void ReleaseStringChars(JNIEnv* env, jstring java_string, const jchar*) {
-    ScopedJniThreadState ts(env);
-    UnpinPrimitiveArray(ts, ts.Decode<String*>(java_string)->GetCharArray());
+    ScopedObjectAccess soa(env);
+    UnpinPrimitiveArray(soa, soa.Decode<String*>(java_string)->GetCharArray());
   }
 
   static const jchar* GetStringCritical(JNIEnv* env, jstring java_string, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     return GetStringChars(env, java_string, is_copy);
   }
 
   static void ReleaseStringCritical(JNIEnv* env, jstring java_string, const jchar* chars) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     return ReleaseStringChars(env, java_string, chars);
   }
 
   static const char* GetStringUTFChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     if (java_string == NULL) {
       return NULL;
     }
     if (is_copy != NULL) {
       *is_copy = JNI_TRUE;
     }
-    String* s = ts.Decode<String*>(java_string);
+    String* s = soa.Decode<String*>(java_string);
     size_t byte_count = s->GetUtfLength();
     char* bytes = new char[byte_count + 1];
     CHECK(bytes != NULL); // bionic aborts anyway.
@@ -1881,73 +1852,73 @@
   }
 
   static void ReleaseStringUTFChars(JNIEnv* env, jstring, const char* chars) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     delete[] chars;
   }
 
   static jsize GetArrayLength(JNIEnv* env, jarray java_array) {
-    ScopedJniThreadState ts(env);
-    Object* obj = ts.Decode<Object*>(java_array);
+    ScopedObjectAccess soa(env);
+    Object* obj = soa.Decode<Object*>(java_array);
     CHECK(obj->IsArrayInstance()); // TODO: ReportJniError
     Array* array = obj->AsArray();
     return array->GetLength();
   }
 
   static jobject GetObjectArrayElement(JNIEnv* env, jobjectArray java_array, jsize index) {
-    ScopedJniThreadState ts(env);
-    ObjectArray<Object>* array = ts.Decode<ObjectArray<Object>*>(java_array);
-    return ts.AddLocalReference<jobject>(array->Get(index));
+    ScopedObjectAccess soa(env);
+    ObjectArray<Object>* array = soa.Decode<ObjectArray<Object>*>(java_array);
+    return soa.AddLocalReference<jobject>(array->Get(index));
   }
 
   static void SetObjectArrayElement(JNIEnv* env,
       jobjectArray java_array, jsize index, jobject java_value) {
-    ScopedJniThreadState ts(env);
-    ObjectArray<Object>* array = ts.Decode<ObjectArray<Object>*>(java_array);
-    Object* value = ts.Decode<Object*>(java_value);
+    ScopedObjectAccess soa(env);
+    ObjectArray<Object>* array = soa.Decode<ObjectArray<Object>*>(java_array);
+    Object* value = soa.Decode<Object*>(java_value);
     array->Set(index, value);
   }
 
   static jbooleanArray NewBooleanArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jbooleanArray, BooleanArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jbooleanArray, BooleanArray>(soa, length);
   }
 
   static jbyteArray NewByteArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jbyteArray, ByteArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jbyteArray, ByteArray>(soa, length);
   }
 
   static jcharArray NewCharArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jcharArray, CharArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jcharArray, CharArray>(soa, length);
   }
 
   static jdoubleArray NewDoubleArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jdoubleArray, DoubleArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jdoubleArray, DoubleArray>(soa, length);
   }
 
   static jfloatArray NewFloatArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jfloatArray, FloatArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jfloatArray, FloatArray>(soa, length);
   }
 
   static jintArray NewIntArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jintArray, IntArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jintArray, IntArray>(soa, length);
   }
 
   static jlongArray NewLongArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jlongArray, LongArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jlongArray, LongArray>(soa, length);
   }
 
   static jobjectArray NewObjectArray(JNIEnv* env, jsize length, jclass element_jclass, jobject initial_element) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     CHECK_GE(length, 0); // TODO: ReportJniError
 
     // Compute the array class corresponding to the given element class.
-    Class* element_class = ts.Decode<Class*>(element_jclass);
+    Class* element_class = soa.Decode<Class*>(element_jclass);
     std::string descriptor;
     descriptor += "[";
     descriptor += ClassHelper(element_class).GetDescriptor();
@@ -1959,26 +1930,26 @@
     }
 
     // Allocate and initialize if necessary.
-    Class* array_class = ts.Decode<Class*>(java_array_class.get());
+    Class* array_class = soa.Decode<Class*>(java_array_class.get());
     ObjectArray<Object>* result = ObjectArray<Object>::Alloc(array_class, length);
     if (initial_element != NULL) {
-      Object* initial_object = ts.Decode<Object*>(initial_element);
+      Object* initial_object = soa.Decode<Object*>(initial_element);
       for (jsize i = 0; i < length; ++i) {
         result->Set(i, initial_object);
       }
     }
-    return ts.AddLocalReference<jobjectArray>(result);
+    return soa.AddLocalReference<jobjectArray>(result);
   }
 
   static jshortArray NewShortArray(JNIEnv* env, jsize length) {
-    ScopedJniThreadState ts(env);
-    return NewPrimitiveArray<jshortArray, ShortArray>(ts, length);
+    ScopedObjectAccess soa(env);
+    return NewPrimitiveArray<jshortArray, ShortArray>(soa, length);
   }
 
   static void* GetPrimitiveArrayCritical(JNIEnv* env, jarray java_array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    Array* array = ts.Decode<Array*>(java_array);
-    PinPrimitiveArray(ts, array);
+    ScopedObjectAccess soa(env);
+    Array* array = soa.Decode<Array*>(java_array);
+    PinPrimitiveArray(soa, array);
     if (is_copy != NULL) {
       *is_copy = JNI_FALSE;
     }
@@ -1986,173 +1957,173 @@
   }
 
   static void ReleasePrimitiveArrayCritical(JNIEnv* env, jarray array, void*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static jboolean* GetBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jbooleanArray, jboolean*, BooleanArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jbooleanArray, jboolean*, BooleanArray>(soa, array, is_copy);
   }
 
   static jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jbyteArray, jbyte*, ByteArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jbyteArray, jbyte*, ByteArray>(soa, array, is_copy);
   }
 
   static jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jcharArray, jchar*, CharArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jcharArray, jchar*, CharArray>(soa, array, is_copy);
   }
 
   static jdouble* GetDoubleArrayElements(JNIEnv* env, jdoubleArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jdoubleArray, jdouble*, DoubleArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jdoubleArray, jdouble*, DoubleArray>(soa, array, is_copy);
   }
 
   static jfloat* GetFloatArrayElements(JNIEnv* env, jfloatArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jfloatArray, jfloat*, FloatArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jfloatArray, jfloat*, FloatArray>(soa, array, is_copy);
   }
 
   static jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jintArray, jint*, IntArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jintArray, jint*, IntArray>(soa, array, is_copy);
   }
 
   static jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jlongArray, jlong*, LongArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jlongArray, jlong*, LongArray>(soa, array, is_copy);
   }
 
   static jshort* GetShortArrayElements(JNIEnv* env, jshortArray array, jboolean* is_copy) {
-    ScopedJniThreadState ts(env);
-    return GetPrimitiveArray<jshortArray, jshort*, ShortArray>(ts, array, is_copy);
+    ScopedObjectAccess soa(env);
+    return GetPrimitiveArray<jshortArray, jshort*, ShortArray>(soa, array, is_copy);
   }
 
   static void ReleaseBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseByteArrayElements(JNIEnv* env, jbyteArray array, jbyte*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseCharArrayElements(JNIEnv* env, jcharArray array, jchar*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseDoubleArrayElements(JNIEnv* env, jdoubleArray array, jdouble*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseFloatArrayElements(JNIEnv* env, jfloatArray array, jfloat*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseIntArrayElements(JNIEnv* env, jintArray array, jint*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseLongArrayElements(JNIEnv* env, jlongArray array, jlong*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void ReleaseShortArrayElements(JNIEnv* env, jshortArray array, jshort*, jint mode) {
-    ScopedJniThreadState ts(env);
-    ReleasePrimitiveArray(ts, array, mode);
+    ScopedObjectAccess soa(env);
+    ReleasePrimitiveArray(soa, array, mode);
   }
 
   static void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length, jboolean* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(soa, array, start, length, buf);
   }
 
   static void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length, jbyte* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(soa, array, start, length, buf);
   }
 
   static void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length, jchar* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(soa, array, start, length, buf);
   }
 
   static void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length, jdouble* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(soa, array, start, length, buf);
   }
 
   static void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length, jfloat* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(soa, array, start, length, buf);
   }
 
   static void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length, jint* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jintArray, jint, IntArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jintArray, jint, IntArray>(soa, array, start, length, buf);
   }
 
   static void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length, jlong* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(soa, array, start, length, buf);
   }
 
   static void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length, jshort* buf) {
-    ScopedJniThreadState ts(env);
-    GetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    GetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(soa, array, start, length, buf);
   }
 
   static void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length, const jboolean* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(soa, array, start, length, buf);
   }
 
   static void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length, const jbyte* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(soa, array, start, length, buf);
   }
 
   static void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length, const jchar* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(soa, array, start, length, buf);
   }
 
   static void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length, const jdouble* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(soa, array, start, length, buf);
   }
 
   static void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length, const jfloat* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(soa, array, start, length, buf);
   }
 
   static void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length, const jint* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jintArray, jint, IntArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jintArray, jint, IntArray>(soa, array, start, length, buf);
   }
 
   static void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length, const jlong* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(soa, array, start, length, buf);
   }
 
   static void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length, const jshort* buf) {
-    ScopedJniThreadState ts(env);
-    SetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(ts, array, start, length, buf);
+    ScopedObjectAccess soa(env);
+    SetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(soa, array, start, length, buf);
   }
 
   static jint RegisterNatives(JNIEnv* env, jclass java_class, const JNINativeMethod* methods, jint method_count) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
 
     for (int i = 0; i < method_count; i++) {
       const char* name = methods[i].name;
@@ -2169,67 +2140,69 @@
       }
       if (m == NULL) {
         LOG(INFO) << "Failed to register native method " << name << sig;
-        ThrowNoSuchMethodError(ts, c, name, sig, "static or non-static");
+        ThrowNoSuchMethodError(soa, c, name, sig, "static or non-static");
         return JNI_ERR;
       } else if (!m->IsNative()) {
         LOG(INFO) << "Failed to register non-native method " << name << sig << " as native";
-        ThrowNoSuchMethodError(ts, c, name, sig, "native");
+        ThrowNoSuchMethodError(soa, c, name, sig, "native");
         return JNI_ERR;
       }
 
       VLOG(jni) << "[Registering JNI native method " << PrettyMethod(m) << "]";
 
-      m->RegisterNative(ts.Self(), methods[i].fnPtr);
+      m->RegisterNative(soa.Self(), methods[i].fnPtr);
     }
     return JNI_OK;
   }
 
   static jint UnregisterNatives(JNIEnv* env, jclass java_class) {
-    ScopedJniThreadState ts(env);
-    Class* c = ts.Decode<Class*>(java_class);
+    ScopedObjectAccess soa(env);
+    Class* c = soa.Decode<Class*>(java_class);
 
     VLOG(jni) << "[Unregistering JNI native methods for " << PrettyClass(c) << "]";
 
     for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
       Method* m = c->GetDirectMethod(i);
       if (m->IsNative()) {
-        m->UnregisterNative(ts.Self());
+        m->UnregisterNative(soa.Self());
       }
     }
     for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
       Method* m = c->GetVirtualMethod(i);
       if (m->IsNative()) {
-        m->UnregisterNative(ts.Self());
+        m->UnregisterNative(soa.Self());
       }
     }
 
     return JNI_OK;
   }
 
-  static jint MonitorEnter(JNIEnv* env, jobject java_object) {
-    ScopedJniThreadState ts(env);
-    Object* o = ts.Decode<Object*>(java_object);
-    o->MonitorEnter(ts.Self());
-    if (ts.Self()->IsExceptionPending()) {
+  static jint MonitorEnter(JNIEnv* env, jobject java_object)
+      EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
+    ScopedObjectAccess soa(env);
+    Object* o = soa.Decode<Object*>(java_object);
+    o->MonitorEnter(soa.Self());
+    if (soa.Self()->IsExceptionPending()) {
       return JNI_ERR;
     }
-    ts.Env()->monitors.Add(o);
+    soa.Env()->monitors.Add(o);
     return JNI_OK;
   }
 
-  static jint MonitorExit(JNIEnv* env, jobject java_object) {
-    ScopedJniThreadState ts(env);
-    Object* o = ts.Decode<Object*>(java_object);
-    o->MonitorExit(ts.Self());
-    if (ts.Self()->IsExceptionPending()) {
+  static jint MonitorExit(JNIEnv* env, jobject java_object)
+      UNLOCK_FUNCTION(monitor_lock_) {
+    ScopedObjectAccess soa(env);
+    Object* o = soa.Decode<Object*>(java_object);
+    o->MonitorExit(soa.Self());
+    if (soa.Self()->IsExceptionPending()) {
       return JNI_ERR;
     }
-    ts.Env()->monitors.Remove(o);
+    soa.Env()->monitors.Remove(o);
     return JNI_OK;
   }
 
   static jint GetJavaVM(JNIEnv* env, JavaVM** vm) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     Runtime* runtime = Runtime::Current();
     if (runtime != NULL) {
       *vm = runtime->GetJavaVM();
@@ -2240,13 +2213,13 @@
   }
 
   static jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
 
     // The address may not be NULL, and the capacity must be > 0.
     CHECK(address != NULL); // TODO: ReportJniError
     CHECK_GT(capacity, 0); // TODO: ReportJniError
 
-    // At the moment, the Java side is limited to 32 bits.
+    // At the moment, the Java side is limited to 32 bisoa.
     CHECK_LE(reinterpret_cast<uintptr_t>(address), 0xffffffff);
     CHECK_LE(capacity, 0xffffffff);
     jint address_arg = reinterpret_cast<jint>(address);
@@ -2255,21 +2228,21 @@
     jobject result = env->NewObject(WellKnownClasses::java_nio_ReadWriteDirectByteBuffer,
                                     WellKnownClasses::java_nio_ReadWriteDirectByteBuffer_init,
                                     address_arg, capacity_arg);
-    return ts.Self()->IsExceptionPending() ? NULL : result;
+    return soa.Self()->IsExceptionPending() ? NULL : result;
   }
 
   static void* GetDirectBufferAddress(JNIEnv* env, jobject java_buffer) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     return reinterpret_cast<void*>(env->GetIntField(java_buffer, WellKnownClasses::java_nio_ReadWriteDirectByteBuffer_effectiveDirectAddress));
   }
 
   static jlong GetDirectBufferCapacity(JNIEnv* env, jobject java_buffer) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
     return static_cast<jlong>(env->GetIntField(java_buffer, WellKnownClasses::java_nio_ReadWriteDirectByteBuffer_capacity));
   }
 
   static jobjectRefType GetObjectRefType(JNIEnv* env, jobject java_object) {
-    ScopedJniThreadState ts(env);
+    ScopedObjectAccess soa(env);
 
     CHECK(java_object != NULL); // TODO: ReportJniError
 
@@ -2278,7 +2251,7 @@
     IndirectRefKind kind = GetIndirectRefKind(ref);
     switch (kind) {
     case kLocal:
-      if (ts.Env()->locals.Get(ref) != kInvalidIndirectRefObject) {
+      if (soa.Env()->locals.Get(ref) != kInvalidIndirectRefObject) {
         return JNILocalRefType;
       }
       return JNIInvalidRefType;
@@ -2288,18 +2261,18 @@
       return JNIWeakGlobalRefType;
     case kSirtOrInvalid:
       // Is it in a stack IRT?
-      if (ts.Self()->SirtContains(java_object)) {
+      if (soa.Self()->SirtContains(java_object)) {
         return JNILocalRefType;
       }
 
-      if (!ts.Vm()->work_around_app_jni_bugs) {
+      if (!soa.Vm()->work_around_app_jni_bugs) {
         return JNIInvalidRefType;
       }
 
       // If we're handing out direct pointers, check whether it's a direct pointer
       // to a local reference.
-      if (ts.Decode<Object*>(java_object) == reinterpret_cast<Object*>(java_object)) {
-        if (ts.Env()->locals.ContainsDirectPointer(reinterpret_cast<Object*>(java_object))) {
+      if (soa.Decode<Object*>(java_object) == reinterpret_cast<Object*>(java_object)) {
+        if (soa.Env()->locals.ContainsDirectPointer(reinterpret_cast<Object*>(java_object))) {
           return JNILocalRefType;
         }
       }
@@ -2309,6 +2282,80 @@
     LOG(FATAL) << "IndirectRefKind[" << kind << "]";
     return JNIInvalidRefType;
   }
+
+ private:
+  static jint EnsureLocalCapacity(const ScopedObjectAccess& soa, jint desired_capacity,
+                                  const char* caller)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    // TODO: we should try to expand the table if necessary.
+    if (desired_capacity < 1 || desired_capacity > static_cast<jint>(kLocalsMax)) {
+      LOG(ERROR) << "Invalid capacity given to " << caller << ": " << desired_capacity;
+      return JNI_ERR;
+    }
+    // TODO: this isn't quite right, since "capacity" includes holes.
+    size_t capacity = soa.Env()->locals.Capacity();
+    bool okay = (static_cast<jint>(kLocalsMax - capacity) >= desired_capacity);
+    if (!okay) {
+      soa.Self()->ThrowOutOfMemoryError(caller);
+    }
+    return okay ? JNI_OK : JNI_ERR;
+  }
+
+  template<typename JniT, typename ArtT>
+  static JniT NewPrimitiveArray(const ScopedObjectAccess& soa, jsize length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    CHECK_GE(length, 0); // TODO: ReportJniError
+    ArtT* result = ArtT::Alloc(length);
+    return soa.AddLocalReference<JniT>(result);
+  }
+
+  template <typename ArrayT, typename CArrayT, typename ArtArrayT>
+  static CArrayT GetPrimitiveArray(ScopedObjectAccess& soa, ArrayT java_array,
+                                   jboolean* is_copy)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    ArtArrayT* array = soa.Decode<ArtArrayT*>(java_array);
+    PinPrimitiveArray(soa, array);
+    if (is_copy != NULL) {
+      *is_copy = JNI_FALSE;
+    }
+    return array->GetData();
+  }
+
+  template <typename ArrayT>
+  static void ReleasePrimitiveArray(ScopedObjectAccess& soa, ArrayT java_array,
+                                    jint mode)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    if (mode != JNI_COMMIT) {
+      Array* array = soa.Decode<Array*>(java_array);
+      UnpinPrimitiveArray(soa, array);
+    }
+  }
+
+  template <typename JavaArrayT, typename JavaT, typename ArrayT>
+  static void GetPrimitiveArrayRegion(ScopedObjectAccess& soa, JavaArrayT java_array,
+                                      jsize start, jsize length, JavaT* buf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    ArrayT* array = soa.Decode<ArrayT*>(java_array);
+    if (start < 0 || length < 0 || start + length > array->GetLength()) {
+      ThrowAIOOBE(soa, array, start, length, "src");
+    } else {
+      JavaT* data = array->GetData();
+      memcpy(buf, data + start, length * sizeof(JavaT));
+    }
+  }
+
+  template <typename JavaArrayT, typename JavaT, typename ArrayT>
+  static void SetPrimitiveArrayRegion(ScopedObjectAccess& soa, JavaArrayT java_array,
+                                      jsize start, jsize length, const JavaT* buf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    ArrayT* array = soa.Decode<ArrayT*>(java_array);
+    if (start < 0 || length < 0 || start + length > array->GetLength()) {
+      ThrowAIOOBE(soa, array, start, length, "dst");
+    } else {
+      JavaT* data = array->GetData();
+      memcpy(data + start, buf, length * sizeof(JavaT));
+    }
+  }
 };
 
 const JNINativeInterface gJniNativeInterface = {
@@ -2603,10 +2650,10 @@
     options.push_back(std::make_pair(std::string(option->optionString), option->extraInfo));
   }
   bool ignore_unrecognized = args->ignoreUnrecognized;
-  Runtime* runtime = Runtime::Create(options, ignore_unrecognized);
-  if (runtime == NULL) {
+  if (!Runtime::Create(options, ignore_unrecognized)) {
     return JNI_ERR;
   }
+  Runtime* runtime = Runtime::Current();
   runtime->Start();
   *p_env = Thread::Current()->GetJniEnv();
   *p_vm = runtime->GetJavaVM();
@@ -2700,7 +2747,7 @@
       globals(gGlobalsInitial, gGlobalsMax, kGlobal),
       weak_globals_lock("JNI weak global reference table lock"),
       weak_globals(kWeakGlobalsInitial, kWeakGlobalsMax, kWeakGlobal),
-      libraries_lock("JNI shared libraries map lock"),
+      libraries_lock("JNI shared libraries map lock", kLoadLibraryLock),
       libraries(new Libraries) {
   functions = unchecked_functions = &gJniInvokeInterface;
   if (options->check_jni_) {
@@ -2760,7 +2807,8 @@
   }
 }
 
-bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_loader, std::string& detail) {
+bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_loader,
+                                  std::string& detail) {
   detail.clear();
 
   // See if we've already loaded this library.  If we have, and the class loader
@@ -2815,18 +2863,18 @@
   //   - write a trivial app that calls sleep() then dlopen(), attach
   //     to it with "strace -p <pid>" while it sleeps, and watch for
   //     attempts to open nonexistent dependent shared libs
-
   // TODO: automate some of these checks!
 
+  // Below we dlopen but there is no paired dlclose, this would be necessary if we supported
+  // class unloading. Libraries will only be unloaded when the reference count (incremented by
+  // dlopen) becomes zero from dlclose.
+
   // This can execute slowly for a large library on a busy system, so we
-  // want to switch from kRunnable to kVmWait while it executes.  This allows
-  // the GC to ignore us.
+  // want to switch from kRunnable while it executes.  This allows the GC to ignore us.
   Thread* self = Thread::Current();
-  void* handle = NULL;
-  {
-    ScopedThreadStateChange tsc(self, kVmWait);
-    handle = dlopen(path.empty() ? NULL : path.c_str(), RTLD_LAZY);
-  }
+  self->TransitionFromRunnableToSuspended(kWaitingForJniOnLoad);
+  void* handle = dlopen(path.empty() ? NULL : path.c_str(), RTLD_LAZY);
+  self->TransitionFromSuspendedToRunnable();
 
   VLOG(jni) << "[Call to dlopen(\"" << path << "\") returned " << handle << "]";
 
@@ -2836,17 +2884,21 @@
   }
 
   // Create a new entry.
+  // TODO: move the locking (and more of this logic) into Libraries.
+  bool created_library = false;
   {
-    // TODO: move the locking (and more of this logic) into Libraries.
     MutexLock mu(libraries_lock);
     library = libraries->Get(path);
-    if (library != NULL) {
-      LOG(INFO) << "WOW: we lost a race to add shared library: "
-                << "\"" << path << "\" ClassLoader=" << class_loader;
-      return library->CheckOnLoadResult();
+    if (library == NULL) {  // We won race to get libraries_lock
+      library = new SharedLibrary(path, handle, class_loader);
+      libraries->Put(path, library);
+      created_library = true;
     }
-    library = new SharedLibrary(path, handle, class_loader);
-    libraries->Put(path, library);
+  }
+  if (!created_library) {
+    LOG(INFO) << "WOW: we lost a race to add shared library: "
+        << "\"" << path << "\" ClassLoader=" << class_loader;
+    return library->CheckOnLoadResult();
   }
 
   VLOG(jni) << "[Added shared library \"" << path << "\" for ClassLoader " << class_loader << "]";
diff --git a/src/jni_internal.h b/src/jni_internal.h
index b96a4d7..fad06e1 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -43,17 +43,20 @@
 union JValue;
 class Libraries;
 class Method;
-class ScopedJniThreadState;
+class ScopedObjectAccess;
 class Thread;
 
 void SetJniGlobalsMax(size_t max);
 void JniAbortF(const char* jni_function_name, const char* fmt, ...);
 void* FindNativeMethod(Thread* thread);
-void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINativeMethod* methods, size_t method_count);
+void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINativeMethod* methods,
+                           size_t method_count);
 
 size_t NumArgArrayBytes(const char* shorty, uint32_t shorty_len);
-JValue InvokeWithJValues(const ScopedJniThreadState&, jobject obj, jmethodID mid, jvalue* args);
-JValue InvokeWithJValues(const ScopedJniThreadState&, Object* receiver, Method* m, JValue* args);
+JValue InvokeWithJValues(const ScopedObjectAccess&, jobject obj, jmethodID mid, jvalue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+JValue InvokeWithJValues(const ScopedObjectAccess&, Object* receiver, Method* m, JValue* args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause);
 
@@ -67,17 +70,20 @@
    * Returns 'true' on success. On failure, sets 'detail' to a
    * human-readable description of the error.
    */
-  bool LoadNativeLibrary(const std::string& path, ClassLoader* class_loader, std::string& detail);
+  bool LoadNativeLibrary(const std::string& path, ClassLoader* class_loader, std::string& detail)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /**
    * Returns a pointer to the code for the native method 'm', found
    * using dlsym(3) on every native library that's been loaded so far.
    */
-  void* FindCodeForNativeMethod(Method* m);
+  void* FindCodeForNativeMethod(Method* m)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void DumpForSigQuit(std::ostream& os);
 
-  void DumpReferenceTables(std::ostream& os);
+  void DumpReferenceTables(std::ostream& os)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void SetCheckJniEnabled(bool enabled);
 
@@ -100,18 +106,18 @@
   bool work_around_app_jni_bugs;
 
   // Used to hold references to pinned primitive arrays.
-  Mutex pins_lock;
+  Mutex pins_lock DEFAULT_MUTEX_ACQUIRED_AFTER;
   ReferenceTable pin_table GUARDED_BY(pins_lock);
 
   // JNI global references.
-  Mutex globals_lock;
+  Mutex globals_lock DEFAULT_MUTEX_ACQUIRED_AFTER;
   IndirectReferenceTable globals GUARDED_BY(globals_lock);
 
   // JNI weak global references.
-  Mutex weak_globals_lock;
+  Mutex weak_globals_lock DEFAULT_MUTEX_ACQUIRED_AFTER;
   IndirectReferenceTable weak_globals GUARDED_BY(weak_globals_lock);
 
-  Mutex libraries_lock;
+  Mutex libraries_lock DEFAULT_MUTEX_ACQUIRED_AFTER;
   Libraries* libraries GUARDED_BY(libraries_lock);
 
   // Used by -Xcheck:jni.
@@ -122,7 +128,8 @@
   JNIEnvExt(Thread* self, JavaVMExt* vm);
   ~JNIEnvExt();
 
-  void DumpReferenceTables(std::ostream& os);
+  void DumpReferenceTables(std::ostream& os)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void SetCheckJniEnabled(bool enabled);
 
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index daca1b5..64461b0 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -20,7 +20,6 @@
 
 #include "common_test.h"
 #include "ScopedLocalRef.h"
-#include "scoped_jni_thread_state.h"
 
 namespace art {
 
@@ -69,9 +68,12 @@
     CommonTest::TearDown();
   }
 
-  Method::InvokeStub* DoCompile(Method*& method, Object*& receiver, bool is_static, const char* method_name, const char* method_signature) {
+  Method::InvokeStub* DoCompile(Method*& method, Object*& receiver, bool is_static,
+                                const char* method_name, const char* method_signature)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const char* class_name = is_static ? "StaticLeafMethods" : "NonStaticLeafMethods";
-    SirtRef<ClassLoader> class_loader(LoadDex(class_name));
+    jobject jclass_loader(LoadDex(class_name));
+    SirtRef<ClassLoader> class_loader(ScopedObjectAccessUnchecked(Thread::Current()).Decode<ClassLoader*>(jclass_loader));
     if (is_static) {
       CompileDirectMethod(class_loader.get(), class_name, method_name, method_signature);
     } else {
@@ -83,7 +85,8 @@
     Class* c = class_linker_->FindClass(DotToDescriptor(class_name).c_str(), class_loader.get());
     CHECK(c != NULL);
 
-    method = is_static ? c->FindDirectMethod(method_name, method_signature) : c->FindVirtualMethod(method_name, method_signature);
+    method = is_static ? c->FindDirectMethod(method_name, method_signature)
+                       : c->FindVirtualMethod(method_name, method_signature);
     CHECK(method != NULL);
 
     receiver = (is_static ? NULL : c->AllocObject());
@@ -94,14 +97,15 @@
     return stub;
   }
 
-  void InvokeNopMethod(bool is_static) {
+  void InvokeNopMethod(bool is_static) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "nop", "()V");
     (*stub)(method, receiver, Thread::Current(), NULL, NULL);
   }
 
-  void InvokeIdentityByteMethod(bool is_static) {
+  void InvokeIdentityByteMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(B)B");
@@ -130,7 +134,8 @@
     EXPECT_EQ(SCHAR_MIN, result.GetB());
   }
 
-  void InvokeIdentityIntMethod(bool is_static) {
+  void InvokeIdentityIntMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(I)I");
@@ -159,7 +164,8 @@
     EXPECT_EQ(INT_MIN, result.GetI());
   }
 
-  void InvokeIdentityDoubleMethod(bool is_static) {
+  void InvokeIdentityDoubleMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(D)D");
@@ -188,7 +194,8 @@
     EXPECT_EQ(DBL_MIN, result.GetD());
   }
 
-  void InvokeSumIntIntMethod(bool is_static) {
+  void InvokeSumIntIntMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(II)I");
@@ -226,7 +233,8 @@
     EXPECT_EQ(-2, result.GetI());
   }
 
-  void InvokeSumIntIntIntMethod(bool is_static) {
+  void InvokeSumIntIntIntMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(III)I");
@@ -269,7 +277,8 @@
     EXPECT_EQ(2147483645, result.GetI());
   }
 
-  void InvokeSumIntIntIntIntMethod(bool is_static) {
+  void InvokeSumIntIntIntIntMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIII)I");
@@ -317,7 +326,8 @@
     EXPECT_EQ(-4, result.GetI());
   }
 
-  void InvokeSumIntIntIntIntIntMethod(bool is_static) {
+  void InvokeSumIntIntIntIntIntMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
@@ -370,7 +380,8 @@
     EXPECT_EQ(2147483643, result.GetI());
   }
 
-  void InvokeSumDoubleDoubleMethod(bool is_static) {
+  void InvokeSumDoubleDoubleMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DD)D");
@@ -409,7 +420,8 @@
     EXPECT_EQ(INFINITY, result.GetD());
   }
 
-  void InvokeSumDoubleDoubleDoubleMethod(bool is_static) {
+  void InvokeSumDoubleDoubleDoubleMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDD)D");
@@ -439,7 +451,8 @@
     EXPECT_EQ(2.0, result.GetD());
   }
 
-  void InvokeSumDoubleDoubleDoubleDoubleMethod(bool is_static) {
+  void InvokeSumDoubleDoubleDoubleDoubleMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
@@ -472,7 +485,8 @@
     EXPECT_EQ(-2.0, result.GetD());
   }
 
-  void InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(bool is_static) {
+  void InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method;
     Object* receiver;
     Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
@@ -1143,7 +1157,8 @@
 
 #if !defined(ART_USE_LLVM_COMPILER)
 TEST_F(JniInternalTest, GetPrimitiveField_SetPrimitiveField) {
-  SirtRef<ClassLoader> class_loader(LoadDex("AllFields"));
+  Thread::Current()->TransitionFromSuspendedToRunnable();
+  LoadDex("AllFields");
   runtime_->Start();
 
   jclass c = env_->FindClass("AllFields");
@@ -1171,7 +1186,8 @@
 }
 
 TEST_F(JniInternalTest, GetObjectField_SetObjectField) {
-  SirtRef<ClassLoader> class_loader(LoadDex("AllFields"));
+  Thread::Current()->TransitionFromSuspendedToRunnable();
+  LoadDex("AllFields");
   runtime_->Start();
 
   jclass c = env_->FindClass("AllFields");
@@ -1228,7 +1244,7 @@
   {
     CheckJniAbortCatcher check_jni_abort_catcher;
     env_->DeleteLocalRef(s);
-    check_jni_abort_catcher.Check("native code passing in reference to invalid local reference: 0x200001");
+    check_jni_abort_catcher.Check("native code passing in reference to invalid local reference: 0x1400001");
   }
 
   s = env_->NewStringUTF("");
@@ -1246,7 +1262,7 @@
 
   jobject outer;
   jobject inner1, inner2;
-  ScopedJniThreadState ts(env_);
+  ScopedObjectAccess soa(env_);
   Object* inner2_direct_pointer;
   {
     env_->PushLocalFrame(4);
@@ -1256,7 +1272,7 @@
       env_->PushLocalFrame(4);
       inner1 = env_->NewLocalRef(outer);
       inner2 = env_->NewStringUTF("survivor");
-      inner2_direct_pointer = ts.Decode<Object*>(inner2);
+      inner2_direct_pointer = soa.Decode<Object*>(inner2);
       env_->PopLocalFrame(inner2);
     }
 
@@ -1309,7 +1325,7 @@
   {
     CheckJniAbortCatcher check_jni_abort_catcher;
     env_->DeleteGlobalRef(o);
-    check_jni_abort_catcher.Check("native code passing in reference to invalid global reference: 0x10000e");
+    check_jni_abort_catcher.Check("native code passing in reference to invalid global reference: 0x100056");
   }
 
   jobject o1 = env_->NewGlobalRef(s);
@@ -1364,7 +1380,9 @@
 }
 
 TEST_F(JniInternalTest, StaticMainMethod) {
-  SirtRef<ClassLoader> class_loader(LoadDex("Main"));
+  ScopedObjectAccess soa(Thread::Current());
+  jobject jclass_loader = LoadDex("Main");
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
   CompileDirectMethod(class_loader.get(), "Main", "main", "([Ljava/lang/String;)V");
 
   Class* klass = class_linker_->FindClass("LMain;", class_loader.get());
@@ -1382,98 +1400,122 @@
 }
 
 TEST_F(JniInternalTest, StaticNopMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeNopMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticNopMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeNopMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticIdentityByteMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityByteMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticIdentityByteMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityByteMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticIdentityIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityIntMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticIdentityIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityIntMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticIdentityDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityDoubleMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticIdentityDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeIdentityDoubleMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumIntIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntIntMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumIntIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntIntMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumIntIntIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntIntIntMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumIntIntIntIntIntMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumIntIntIntIntIntMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleDoubleMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumDoubleDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleDoubleMethod(false);
 }
 
 TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(true);
 }
 
 TEST_F(JniInternalTest, NonStaticSumDoubleDoubleDoubleDoubleDoubleMethod) {
+  ScopedObjectAccess soa(Thread::Current());
   InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(false);
 }
 
diff --git a/src/jobject_comparator.cc b/src/jobject_comparator.cc
new file mode 100644
index 0000000..edd0727
--- /dev/null
+++ b/src/jobject_comparator.cc
@@ -0,0 +1,55 @@
+/*
+ * 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 "jobject_comparator.h"
+
+#include "object.h"
+#include "scoped_thread_state_change.h"
+
+namespace art {
+
+bool JobjectComparator::operator()(jobject jobj1, jobject jobj2) const {
+  // Ensure null references and cleared jweaks appear at the end.
+  if (jobj1 == NULL) {
+    return true;
+  } else if (jobj2 == NULL) {
+    return false;
+  }
+  ScopedObjectAccess soa(Thread::Current());
+  Object* obj1 = soa.Decode<Object*>(jobj1);
+  Object* obj2 = soa.Decode<Object*>(jobj2);
+  if (obj1 == NULL) {
+    return true;
+  } else if (obj2 == NULL) {
+    return false;
+  }
+  // Sort by class...
+  if (obj1->GetClass() != obj2->GetClass()) {
+    return obj1->GetClass()->IdentityHashCode() < obj2->IdentityHashCode();
+  } else {
+    // ...then by size...
+    size_t count1 = obj1->SizeOf();
+    size_t count2 = obj2->SizeOf();
+    if (count1 != count2) {
+      return count1 < count2;
+    } else {
+      // ...and finally by identity hash code.
+      return obj1->IdentityHashCode() < obj2->IdentityHashCode();
+    }
+  }
+}
+
+}  // namespace art
diff --git a/src/scoped_thread_list_lock.h b/src/jobject_comparator.h
similarity index 68%
rename from src/scoped_thread_list_lock.h
rename to src/jobject_comparator.h
index 8650c57..17098aa 100644
--- a/src/scoped_thread_list_lock.h
+++ b/src/jobject_comparator.h
@@ -14,22 +14,17 @@
  * limitations under the License.
  */
 
-#ifndef ART_SRC_SCOPED_THREAD_LIST_LOCK_H_
-#define ART_SRC_SCOPED_THREAD_LIST_LOCK_H_
+#ifndef ART_SRC_JOBJECT_COMPARATOR_H_
+#define ART_SRC_JOBJECT_COMPARATOR_H_
 
-#include "macros.h"
+#include <jni.h>
 
 namespace art {
 
-class ScopedThreadListLock {
- public:
-  ScopedThreadListLock();
-  ~ScopedThreadListLock();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedThreadListLock);
+struct JobjectComparator {
+  bool operator()(jobject jobj1, jobject jobj2) const;
 };
 
 }  // namespace art
 
-#endif  // ART_SRC_SCOPED_THREAD_LIST_LOCK_H_
+#endif  // ART_SRC_JOBJECT_COMPARATOR_H_
diff --git a/src/logging.cc b/src/logging.cc
index 30063a1..712c02b 100644
--- a/src/logging.cc
+++ b/src/logging.cc
@@ -29,11 +29,6 @@
 static std::string* gProgramInvocationName;
 static std::string* gProgramInvocationShortName;
 
-static Mutex& GetLoggingLock() {
-  static Mutex logging_lock("LogMessage lock");
-  return logging_lock;
-}
-
 const char* GetCmdLine() {
   return (gCmdLine != NULL) ? gCmdLine->c_str() : NULL;
 }
@@ -55,6 +50,9 @@
 // and a letter indicating the minimum priority level we're expected to log.
 // This can be used to reveal or conceal logs with specific tags.
 void InitLogging(char* argv[]) {
+  // TODO: Move this to a more obvious InitART...
+  GlobalSynchronization::Init();
+
   // Stash the command line for later use. We can use /proc/self/cmdline on Linux to recover this,
   // but we don't have that luxury on the Mac, and there are a couple of argv[0] variants that are
   // commonly used.
@@ -106,7 +104,7 @@
 
   // Do the actual logging with the lock held.
   {
-    MutexLock mu(GetLoggingLock());
+    MutexLock mu(*GlobalSynchronization::logging_lock_);
     if (msg.find('\n') == std::string::npos) {
       LogLine(msg.c_str());
     } else {
diff --git a/src/logging.h b/src/logging.h
index 94dd2c6..ce86a72 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -187,7 +187,7 @@
 class LogMessage {
  public:
   LogMessage(const char* file, int line, LogSeverity severity, int error);
-  ~LogMessage();
+  ~LogMessage() LOCKS_EXCLUDED(GlobalSynchronization::logging_lock_);
   std::ostream& stream();
 
  private:
@@ -249,6 +249,35 @@
   return os;
 }
 
+template<typename T>
+class MutatorLockedDumpable {
+ public:
+  explicit MutatorLockedDumpable(T& value)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) : value_(value) {
+  }
+
+  void Dump(std::ostream& os) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    value_.Dump(os);
+  }
+
+ private:
+  T& value_;
+
+// TODO: Remove the #if when Mac OS build server no longer uses GCC 4.2.*.
+#if GCC_VERSION >= 40300
+  DISALLOW_COPY_AND_ASSIGN(MutatorLockedDumpable);
+#endif
+};
+
+template<typename T>
+std::ostream& operator<<(std::ostream& os, const MutatorLockedDumpable<T>& rhs)
+// TODO: should be SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) however annotalysis
+//       currently fails for this.
+    NO_THREAD_SAFETY_ANALYSIS {
+  rhs.Dump(os);
+  return os;
+}
+
 // Helps you use operator<< in a const char*-like context such as our various 'F' methods with
 // format strings.
 template<typename T>
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 7adc344..227614d 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -30,7 +30,6 @@
 #include "monitor.h"
 #include "object.h"
 #include "runtime.h"
-#include "scoped_heap_lock.h"
 #include "space.h"
 #include "timing_logger.h"
 #include "thread.h"
@@ -133,7 +132,9 @@
 
   }
 
-  void operator ()(const Object* obj, const Object* ref, MemberOffset offset, bool is_static) const {
+  void operator ()(const Object* obj, const Object* ref, MemberOffset offset, bool is_static) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     mark_sweep_->CheckReference(obj, ref, offset, is_static);
   }
 
@@ -171,10 +172,11 @@
 class ScanImageRootVisitor {
  public:
   ScanImageRootVisitor(MarkSweep* const mark_sweep) : mark_sweep_(mark_sweep) {
-
   }
 
-  void operator ()(const Object* root) const {
+  void operator ()(const Object* root) const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(root != NULL);
     mark_sweep_->ScanObject(root);
   }
@@ -225,7 +227,9 @@
 
   }
 
-  void operator ()(const Object* obj) const {
+  void operator ()(const Object* obj) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     mark_sweep_->CheckObject(obj);
   }
@@ -322,7 +326,7 @@
 };
 
 void MarkSweep::SweepCallback(size_t num_ptrs, Object** ptrs, void* arg) {
-  ScopedHeapLock lock;
+  GlobalSynchronization::heap_bitmap_lock_->AssertExclusiveHeld();
 
   size_t freed_objects = num_ptrs;
   size_t freed_bytes = 0;
@@ -348,11 +352,12 @@
       space->Free(obj);
     }
   }
-  heap->RecordFreeLocked(freed_objects, freed_bytes);
+  heap->RecordFree(freed_objects, freed_bytes);
 }
 
 void MarkSweep::ZygoteSweepCallback(size_t num_ptrs, Object** ptrs, void* arg) {
-  ScopedHeapLock lock;
+  GlobalSynchronization::heap_bitmap_lock_->AssertExclusiveHeld();
+
   SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
   Heap* heap = context->heap;
   // We don't free any actual memory to avoid dirtying the shared zygote pages.
diff --git a/src/mark_sweep.h b/src/mark_sweep.h
index 189462f..bb48b7a 100644
--- a/src/mark_sweep.h
+++ b/src/mark_sweep.h
@@ -44,36 +44,46 @@
   void Init();
 
   // Marks the root set at the start of a garbage collection.
-  void MarkRoots();
+  void MarkRoots()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Marks the roots in the image space on dirty cards.
-  void ScanDirtyImageRoots();
+  void ScanDirtyImageRoots() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Verify that image roots point to only marked objects within the alloc space.
-  void VerifyImageRoots();
+  void VerifyImageRoots() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   bool IsMarkStackEmpty() const {
     return mark_stack_->IsEmpty();
   }
 
   // Builds a mark stack and recursively mark until it empties.
-  void RecursiveMark(bool partial);
+  void RecursiveMark(bool partial)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Copies mark bits from live bitmap of zygote space to mark bitmap for partial GCs.
   void CopyMarkBits();
 
   // Builds a mark stack with objects on dirty cards and recursively mark
   // until it empties.
-  void RecursiveMarkDirtyObjects();
+  void RecursiveMarkDirtyObjects()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Remarks the root set after completing the concurrent mark.
-  void ReMarkRoots();
+  void ReMarkRoots()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Heap* GetHeap() {
     return heap_;
   }
 
-  void ProcessReferences(bool clear_soft_references) {
+  void ProcessReferences(bool clear_soft_references)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ProcessReferences(&soft_reference_list_, clear_soft_references,
                       &weak_reference_list_,
                       &finalizer_reference_list_,
@@ -81,59 +91,83 @@
   }
 
   // Sweeps unmarked objects to complete the garbage collection.
-  void Sweep(bool partial);
+  void Sweep(bool partial) EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   Object* GetClearedReferences() {
     return cleared_reference_list_;
   }
 
   // Blackens an object.
-  void ScanObject(const Object* obj);
+  void ScanObject(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   // Returns true if the object has its bit set in the mark bitmap.
-  bool IsMarked(const Object* object) const {
+  bool IsMarked(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     if (current_mark_bitmap_->HasAddress(object)) {
       return current_mark_bitmap_->Test(object);
     }
     return heap_->GetMarkBitmap()->Test(object);
   }
 
-  static bool IsMarkedCallback(const Object* object, void* arg) {
+  static bool IsMarkedCallback(const Object* object, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     return reinterpret_cast<MarkSweep*>(arg)->IsMarked(object);
   }
 
-  static bool IsLiveCallback(const Object* object, void* arg) {
+  static bool IsLiveCallback(const Object* object, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     return reinterpret_cast<MarkSweep*>(arg)->GetHeap()->GetLiveBitmap()->Test(object);
   }
 
-  static void MarkObjectVisitor(const Object* root, void* arg);
+  static void MarkObjectVisitor(const Object* root, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
-  static void ReMarkObjectVisitor(const Object* root, void* arg);
+  static void ReMarkObjectVisitor(const Object* root, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
-  static void VerifyImageRootVisitor(Object* root, void* arg);
+  static void VerifyImageRootVisitor(Object* root, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_);
 
-  static void ScanDirtyCardCallback(Object* obj, void* arg);
+  static void ScanDirtyCardCallback(Object* obj, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Marks an object.
-  void MarkObject(const Object* obj);
+  void MarkObject(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Yuck.
-  void MarkObject0(const Object* obj, bool check_finger);
+  void MarkObject0(const Object* obj, bool check_finger)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
-  static void ScanBitmapCallback(Object* obj, void* finger, void* arg);
+  static void ScanBitmapCallback(Object* obj, void* finger, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static void SweepCallback(size_t num_ptrs, Object** ptrs, void* arg);
+
+  static void SweepCallback(size_t num_ptrs, Object** ptrs, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Special sweep for zygote that just marks objects / dirties cards.
-  static void ZygoteSweepCallback(size_t num_ptrs, Object** ptrs, void* arg);
+  static void ZygoteSweepCallback(size_t num_ptrs, Object** ptrs, void* arg)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
-  void CheckReference(const Object* obj, const Object* ref, MemberOffset offset, bool is_static);
+  void CheckReference(const Object* obj, const Object* ref, MemberOffset offset, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_);
 
-  void CheckObject(const Object* obj);
+  void CheckObject(const Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitObjectReferences(const Object* obj, const Visitor& visitor) {
+  void VisitObjectReferences(const Object* obj, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     DCHECK(obj->GetClass() != NULL);
     if (obj->IsClass()) {
@@ -146,10 +180,14 @@
   }
 
   // Grays references in instance fields.
-  void ScanInstanceFields(const Object* obj);
+  void ScanInstanceFields(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitInstanceFieldsReferences(const Object* obj, const Visitor& visitor) {
+  void VisitInstanceFieldsReferences(const Object* obj, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     Class* klass = obj->GetClass();
     DCHECK(klass != NULL);
@@ -157,28 +195,42 @@
   }
 
   // Blackens a class object.
-  void ScanClass(const Object* obj);
+  void ScanClass(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
 
   template <typename Visitor>
-  void VisitClassReferences(const Object* obj, const Visitor& visitor) {
+  void VisitClassReferences(const Object* obj, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     VisitInstanceFieldsReferences(obj, visitor);
     VisitStaticFieldsReferences(obj->AsClass(), visitor);
   }
 
   // Grays references in static fields.
-  void ScanStaticFields(const Class* klass);
+  void ScanStaticFields(const Class* klass)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitStaticFieldsReferences(const Class* klass, const Visitor& visitor) {
+  void VisitStaticFieldsReferences(const Class* klass, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {\
     DCHECK(klass != NULL);
     VisitFieldsReferences(klass, klass->GetReferenceStaticOffsets(), true, visitor);
   }
 
   // Used by ScanInstanceFields and ScanStaticFields
-  void ScanFields(const Object* obj, uint32_t ref_offsets, bool is_static);
+  void ScanFields(const Object* obj, uint32_t ref_offsets, bool is_static)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitFieldsReferences(const Object* obj, uint32_t ref_offsets, bool is_static, const Visitor& visitor) {
+  void VisitFieldsReferences(const Object* obj, uint32_t ref_offsets, bool is_static,
+                             const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     if (ref_offsets != CLASS_WALK_SUPER) {
       // Found a reference offset bitmap.  Mark the specified offsets.
       while (ref_offsets != 0) {
@@ -212,10 +264,14 @@
   }
 
   // Grays references in an array.
-  void ScanArray(const Object* obj);
+  void ScanArray(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitArrayReferences(const Object* obj, const Visitor& visitor) {
+  void VisitArrayReferences(const Object* obj, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     visitor(obj, obj->GetClass(), Object::ClassOffset(), false);
     if (obj->IsObjectArray()) {
       const ObjectArray<Object>* array = obj->AsObjectArray<Object>();
@@ -227,35 +283,51 @@
     }
   }
 
-  void ScanOther(const Object* obj);
+  void ScanOther(const Object* obj)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   template <typename Visitor>
-  void VisitOtherReferences(const Object* obj, const Visitor& visitor) {
+  void VisitOtherReferences(const Object* obj, const Visitor& visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     return VisitInstanceFieldsReferences(obj, visitor);
   }
 
   // Blackens objects grayed during a garbage collection.
-  void ScanGrayObjects();
+  void ScanGrayObjects() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Schedules an unmarked object for reference processing.
-  void DelayReferenceReferent(Object* reference);
+  void DelayReferenceReferent(Object* reference)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Recursively blackens objects on the mark stack.
-  void ProcessMarkStack();
+  void ProcessMarkStack()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void EnqueueFinalizerReferences(Object** ref);
+  void EnqueueFinalizerReferences(Object** ref)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void PreserveSomeSoftReferences(Object** ref);
+  void PreserveSomeSoftReferences(Object** ref)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void ClearWhiteReferences(Object** list);
+  void ClearWhiteReferences(Object** list)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   void ProcessReferences(Object** soft_references, bool clear_soft_references,
                          Object** weak_references,
                          Object** finalizer_references,
-                         Object** phantom_references);
+                         Object** phantom_references)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void SweepSystemWeaks(bool swap_bitmaps);
-  void SweepJniWeakGlobals(HeapBitmap* bitmap);
+  void SweepSystemWeaks(bool swap_bitmaps)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
+  void SweepJniWeakGlobals(HeapBitmap* bitmap)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Current space, we check this space first to avoid searching for the appropriate space for an object.
   SpaceBitmap* current_mark_bitmap_;
diff --git a/src/mod_union_table.cc b/src/mod_union_table.cc
index 410bf62..3b928e3 100644
--- a/src/mod_union_table.cc
+++ b/src/mod_union_table.cc
@@ -56,7 +56,9 @@
       bitmap_(bitmap) {
   }
 
-  void operator ()(Object* obj) const {
+  void operator ()(Object* obj) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     // We don't have an early exit since we use the visitor pattern, an early
     // exit should significantly speed this up.
@@ -136,10 +138,11 @@
 class ModUnionScanImageRootVisitor {
  public:
   ModUnionScanImageRootVisitor(MarkSweep* const mark_sweep) : mark_sweep_(mark_sweep) {
-
   }
 
-  void operator ()(const Object* root) const {
+  void operator ()(const Object* root) const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(root != NULL);
     mark_sweep_->ScanObject(root);
   }
@@ -208,7 +211,9 @@
       references_(references) {
   }
 
-  void operator ()(Object* obj) const {
+  void operator ()(Object* obj) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_,
+                            GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     // We don't have an early exit since we use the visitor pattern, an early
     // exit should significantly speed this up.
diff --git a/src/mod_union_table.h b/src/mod_union_table.h
index f44004b..424f2f3 100644
--- a/src/mod_union_table.h
+++ b/src/mod_union_table.h
@@ -84,10 +84,12 @@
   void ClearCards(Space* space);
 
   // Update table based on cleared cards.
-  void Update();
+  void Update()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Mark all references to the alloc space(s).
-  void MarkReferences();
+  void MarkReferences() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
  protected:
   // Cleared card array, used to update the mod-union table.
@@ -111,10 +113,12 @@
   void ClearCards(Space* space);
 
   // Update table based on cleared cards.
-  void Update();
+  void Update()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Mark all references to the alloc space(s).
-  void MarkReferences();
+  void MarkReferences() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
   // Verify the mod-union table.
   void Verify();
@@ -146,7 +150,9 @@
   void Update() {}
 
   // Mark all references to the alloc space(s).
-  void MarkReferences();
+  void MarkReferences()
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Nothing to verify.
   void Verify() {}
diff --git a/src/monitor.cc b/src/monitor.cc
index 149babf..0e6735d 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -31,8 +31,7 @@
 #include "mutex.h"
 #include "object.h"
 #include "object_utils.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
+#include "scoped_thread_state_change.h"
 #include "stl_util.h"
 #include "thread.h"
 #include "thread_list.h"
@@ -117,14 +116,26 @@
   is_sensitive_thread_hook_ = is_sensitive_thread_hook;
 }
 
-Monitor::Monitor(Object* obj)
-    : owner_(NULL),
+Monitor::Monitor(Thread* owner, Object* obj)
+    : monitor_lock_("a monitor lock", kMonitorLock),
+      owner_(owner),
       lock_count_(0),
       obj_(obj),
       wait_set_(NULL),
-      lock_("a monitor lock"),
       locking_method_(NULL),
       locking_dex_pc_(0) {
+  monitor_lock_.Lock();
+  // Propagate the lock state.
+  uint32_t thin = *obj->GetRawLockWordAddress();
+  lock_count_ = LW_LOCK_COUNT(thin);
+  thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT;
+  thin |= reinterpret_cast<uint32_t>(this) | LW_SHAPE_FAT;
+  // Publish the updated lock word.
+  android_atomic_release_store(thin, obj->GetRawLockWordAddress());
+  // Lock profiling.
+  if (lock_profiling_threshold_ != 0) {
+    locking_method_ = owner->GetCurrentMethod(&locking_dex_pc_);
+  }
 }
 
 Monitor::~Monitor() {
@@ -190,7 +201,7 @@
     return;
   }
 
-  if (!lock_.TryLock()) {
+  if (!monitor_lock_.TryLock()) {
     uint64_t waitStart = 0;
     uint64_t waitEnd = 0;
     uint32_t wait_threshold = lock_profiling_threshold_;
@@ -204,7 +215,7 @@
       current_locking_method = locking_method_;
       current_locking_dex_pc = locking_dex_pc_;
 
-      lock_.Lock();
+      monitor_lock_.Lock();
       if (wait_threshold != 0) {
         waitEnd = NanoTime() / 1000;
       }
@@ -240,7 +251,8 @@
 static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
                                               __attribute__((format(printf, 1, 2)));
 
-static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...) {
+static void ThrowIllegalMonitorStateExceptionF(const char* fmt, ...)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   va_list args;
   va_start(args, fmt);
   Thread::Current()->ThrowNewExceptionV("Ljava/lang/IllegalMonitorStateException;", fmt, args);
@@ -272,7 +284,7 @@
   {
     // TODO: isn't this too late to prevent threads from disappearing?
     // Acquire thread list lock so threads won't disappear from under us.
-    ScopedThreadListLock thread_list_lock;
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
     // Re-read owner now that we hold lock.
     current_owner = (monitor != NULL) ? monitor->owner_ : NULL;
     // Get short descriptions of the threads involved.
@@ -322,7 +334,7 @@
   }
 }
 
-bool Monitor::Unlock(Thread* self) {
+bool Monitor::Unlock(Thread* self, bool for_wait) {
   DCHECK(self != NULL);
   Thread* owner = owner_;
   if (owner == self) {
@@ -331,10 +343,17 @@
       owner_ = NULL;
       locking_method_ = NULL;
       locking_dex_pc_ = 0;
-      lock_.Unlock();
+      monitor_lock_.Unlock();
     } else {
       --lock_count_;
     }
+  } else if (for_wait) {
+    // Wait should have already cleared the fields.
+    DCHECK_EQ(lock_count_, 0);
+    DCHECK(owner == NULL);
+    DCHECK(locking_method_ == NULL);
+    DCHECK_EQ(locking_dex_pc_, 0u);
+    monitor_lock_.Unlock();
   } else {
     // We don't own this, so we're not allowed to unlock it.
     // The JNI spec says that we should throw IllegalMonitorStateException
@@ -346,7 +365,8 @@
 }
 
 // Converts the given waiting time (relative to "now") into an absolute time in 'ts'.
-static void ToAbsoluteTime(int64_t ms, int32_t ns, timespec* ts) {
+static void ToAbsoluteTime(int64_t ms, int32_t ns, timespec* ts)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   int64_t endSec;
 
 #ifdef HAVE_TIMEDWAIT_MONOTONIC
@@ -407,7 +427,11 @@
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
     return;
   }
+  monitor_lock_.AssertHeld();
+  WaitWithLock(self, ms, ns, interruptShouldThrow);
+}
 
+void Monitor::WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow) {
   // Enforce the timeout range.
   if (ms < 0 || ns < 0 || ns > 999999) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
@@ -447,57 +471,52 @@
    * that we won't touch any references in this state, and we'll check
    * our suspend mode before we transition out.
    */
-  if (timed) {
-    self->SetState(kTimedWaiting);
-  } else {
-    self->SetState(kWaiting);
-  }
+  self->TransitionFromRunnableToSuspended(timed ? kTimedWaiting : kWaiting);
 
-  self->wait_mutex_->Lock();
-
-  /*
-   * Set wait_monitor_ to the monitor object we will be waiting on.
-   * When wait_monitor_ is non-NULL a notifying or interrupting thread
-   * must signal the thread's wait_cond_ to wake it up.
-   */
-  DCHECK(self->wait_monitor_ == NULL);
-  self->wait_monitor_ = this;
-
-  /*
-   * Handle the case where the thread was interrupted before we called
-   * wait().
-   */
   bool wasInterrupted = false;
-  if (self->interrupted_) {
-    wasInterrupted = true;
+  {
+    // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock.
+    MutexLock mu(*self->wait_mutex_);
+
+    // Set wait_monitor_ to the monitor object we will be waiting on. When wait_monitor_ is
+    // non-NULL a notifying or interrupting thread must signal the thread's wait_cond_ to wake it
+    // up.
+    DCHECK(self->wait_monitor_ == NULL);
+    self->wait_monitor_ = this;
+
+    // Release the monitor lock.
+    Unlock(self, true);
+
+    /*
+     * Handle the case where the thread was interrupted before we called
+     * wait().
+     */
+    if (self->interrupted_) {
+      wasInterrupted = true;
+    } else {
+      // Wait for a notification or a timeout to occur.
+      if (!timed) {
+        self->wait_cond_->Wait(*self->wait_mutex_);
+      } else {
+        self->wait_cond_->TimedWait(*self->wait_mutex_, ts);
+      }
+      if (self->interrupted_) {
+        wasInterrupted = true;
+      }
+      self->interrupted_ = false;
+    }
     self->wait_monitor_ = NULL;
-    self->wait_mutex_->Unlock();
-    goto done;
   }
 
-  /*
-   * Release the monitor lock and wait for a notification or
-   * a timeout to occur.
-   */
-  lock_.Unlock();
+  // Set self->status back to kRunnable, and self-suspend if needed.
+  self->TransitionFromSuspendedToRunnable();
 
-  if (!timed) {
-    self->wait_cond_->Wait(*self->wait_mutex_);
-  } else {
-    self->wait_cond_->TimedWait(*self->wait_mutex_, ts);
-  }
-  if (self->interrupted_) {
-    wasInterrupted = true;
-  }
-
-  self->interrupted_ = false;
-  self->wait_monitor_ = NULL;
-  self->wait_mutex_->Unlock();
-
-  // Reacquire the monitor lock.
+  // Re-acquire the monitor lock.
   Lock(self);
 
- done:
+
+  self->wait_mutex_->AssertNotHeld();
+
   /*
    * We remove our thread from wait set after restoring the count
    * and owner fields so the subroutine can check that the calling
@@ -510,9 +529,6 @@
   locking_dex_pc_ = saved_dex_pc;
   RemoveFromWaitSet(self);
 
-  /* set self->status back to kRunnable, and self-suspend if needed */
-  self->SetState(kRunnable);
-
   if (wasInterrupted) {
     /*
      * We were interrupted while waiting, or somebody interrupted an
@@ -521,7 +537,10 @@
      * The doc sayeth: "The interrupted status of the current thread is
      * cleared when this exception is thrown."
      */
-    self->interrupted_ = false;
+    {
+      MutexLock mu(*self->wait_mutex_);
+      self->interrupted_ = false;
+    }
     if (interruptShouldThrow) {
       Thread::Current()->ThrowNewException("Ljava/lang/InterruptedException;", NULL);
     }
@@ -530,12 +549,16 @@
 
 void Monitor::Notify(Thread* self) {
   DCHECK(self != NULL);
-
   // Make sure that we hold the lock.
   if (owner_ != self) {
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
     return;
   }
+  monitor_lock_.AssertHeld();
+  NotifyWithLock();
+}
+
+void Monitor::NotifyWithLock() {
   // Signal the first waiting thread in the wait set.
   while (wait_set_ != NULL) {
     Thread* thread = wait_set_;
@@ -553,12 +576,16 @@
 
 void Monitor::NotifyAll(Thread* self) {
   DCHECK(self != NULL);
-
   // Make sure that we hold the lock.
   if (owner_ != self) {
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
     return;
   }
+  monitor_lock_.AssertHeld();
+  NotifyAllWithLock();
+}
+
+void Monitor::NotifyAllWithLock() {
   // Signal all threads in the wait set.
   while (wait_set_ != NULL) {
     Thread* thread = wait_set_;
@@ -579,18 +606,10 @@
   DCHECK_EQ(LW_LOCK_OWNER(*obj->GetRawLockWordAddress()), static_cast<int32_t>(self->GetThinLockId()));
 
   // Allocate and acquire a new monitor.
-  Monitor* m = new Monitor(obj);
+  Monitor* m = new Monitor(self, obj);
   VLOG(monitor) << "monitor: thread " << self->GetThinLockId()
                 << " created monitor " << m << " for object " << obj;
   Runtime::Current()->GetMonitorList()->Add(m);
-  m->Lock(self);
-  // Propagate the lock state.
-  uint32_t thin = *obj->GetRawLockWordAddress();
-  m->lock_count_ = LW_LOCK_COUNT(thin);
-  thin &= LW_HASH_STATE_MASK << LW_HASH_STATE_SHIFT;
-  thin |= reinterpret_cast<uint32_t>(m) | LW_SHAPE_FAT;
-  // Publish the updated lock word.
-  android_atomic_release_store(thin, obj->GetRawLockWordAddress());
 }
 
 void Monitor::MonitorEnter(Thread* self, Object* obj) {
@@ -639,7 +658,7 @@
                                     threadId, thinp, PrettyTypeOf(obj).c_str(), LW_LOCK_OWNER(thin));
       // The lock is owned by another thread. Notify the runtime that we are about to wait.
       self->monitor_enter_object_ = obj;
-      ThreadState oldStatus = self->SetState(kBlocked);
+      self->TransitionFromRunnableToSuspended(kBlocked);
       // Spin until the thin lock is released or inflated.
       sleepDelayNs = 0;
       for (;;) {
@@ -677,14 +696,14 @@
           // waiting and try again.
           VLOG(monitor) << StringPrintf("monitor: thread %d found lock %p surprise-fattened by another thread", threadId, thinp);
           self->monitor_enter_object_ = NULL;
-          self->SetState(oldStatus);
+          self->TransitionFromSuspendedToRunnable();
           goto retry;
         }
       }
       VLOG(monitor) << StringPrintf("monitor: thread %d spin on lock %p done", threadId, thinp);
       // We have acquired the thin lock. Let the runtime know that we are no longer waiting.
       self->monitor_enter_object_ = NULL;
-      self->SetState(oldStatus);
+      self->TransitionFromSuspendedToRunnable();
       // Fatten the lock.
       Inflate(self, obj);
       VLOG(monitor) << StringPrintf("monitor: thread %d fattened lock %p", threadId, thinp);
@@ -750,7 +769,7 @@
      * raised any exceptions before continuing.
      */
     DCHECK(LW_MONITOR(*thinp) != NULL);
-    if (!LW_MONITOR(*thinp)->Unlock(self)) {
+    if (!LW_MONITOR(*thinp)->Unlock(self, false)) {
       // An exception has been raised.  Do not fall through.
       return false;
     }
@@ -796,6 +815,7 @@
       return;
     }
     // no-op;  there are no waiters to notify.
+    Inflate(self, obj);
   } else {
     // It's a fat lock.
     LW_MONITOR(thin)->Notify(self);
@@ -814,6 +834,7 @@
       return;
     }
     // no-op;  there are no waiters to notify.
+    Inflate(self, obj);
   } else {
     // It's a fat lock.
     LW_MONITOR(thin)->NotifyAll(self);
@@ -830,17 +851,17 @@
 }
 
 static uint32_t LockOwnerFromThreadLock(Object* thread_lock) {
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccess soa(Thread::Current());
   if (thread_lock == NULL ||
-      thread_lock->GetClass() != ts.Decode<Class*>(WellKnownClasses::java_lang_ThreadLock)) {
+      thread_lock->GetClass() != soa.Decode<Class*>(WellKnownClasses::java_lang_ThreadLock)) {
     return ThreadList::kInvalidId;
   }
-  Field* thread_field = ts.DecodeField(WellKnownClasses::java_lang_ThreadLock_thread);
+  Field* thread_field = soa.DecodeField(WellKnownClasses::java_lang_ThreadLock_thread);
   Object* managed_thread = thread_field->GetObject(thread_lock);
   if (managed_thread == NULL) {
     return ThreadList::kInvalidId;
   }
-  Field* vmData_field = ts.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
+  Field* vmData_field = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
   uintptr_t vmData = static_cast<uintptr_t>(vmData_field->GetInt(managed_thread));
   Thread* thread = reinterpret_cast<Thread*>(vmData);
   if (thread == NULL) {
@@ -850,13 +871,21 @@
 }
 
 void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
-  ThreadState state = thread->GetState();
+  ThreadState state;
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    state = thread->GetState();
+  }
 
   Object* object = NULL;
   uint32_t lock_owner = ThreadList::kInvalidId;
   if (state == kWaiting || state == kTimedWaiting) {
     os << "  - waiting on ";
-    Monitor* monitor = thread->wait_monitor_;
+    Monitor* monitor;
+    {
+      MutexLock mu(*thread->wait_mutex_);
+      monitor = thread->wait_monitor_;
+    }
     if (monitor != NULL) {
       object = monitor->obj_;
     }
@@ -883,7 +912,8 @@
   os << "\n";
 }
 
-static void DumpLockedObject(std::ostream& os, Object* o) {
+static void DumpLockedObject(std::ostream& os, Object* o)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   os << "  - locked <" << o << "> (a " << PrettyTypeOf(o) << ")\n";
 }
 
@@ -968,21 +998,21 @@
   line_number = mh.GetLineNumFromDexPC(dex_pc);
 }
 
-MonitorList::MonitorList() : lock_("MonitorList lock") {
+MonitorList::MonitorList() : monitor_list_lock_("MonitorList lock") {
 }
 
 MonitorList::~MonitorList() {
-  MutexLock mu(lock_);
+  MutexLock mu(monitor_list_lock_);
   STLDeleteElements(&list_);
 }
 
 void MonitorList::Add(Monitor* m) {
-  MutexLock mu(lock_);
+  MutexLock mu(monitor_list_lock_);
   list_.push_front(m);
 }
 
 void MonitorList::SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg) {
-  MutexLock mu(lock_);
+  MutexLock mu(monitor_list_lock_);
   typedef std::list<Monitor*>::iterator It; // TODO: C++0x auto
   It it = list_.begin();
   while (it != list_.end()) {
diff --git a/src/monitor.h b/src/monitor.h
index d72ff73..b506b39 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -25,6 +25,7 @@
 
 #include "heap.h"
 #include "mutex.h"
+#include "thread.h"
 
 namespace art {
 
@@ -67,66 +68,96 @@
   static bool IsSensitiveThread();
   static void Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)());
 
-  static uint32_t GetThinLockId(uint32_t raw_lock_word);
+  static uint32_t GetThinLockId(uint32_t raw_lock_word)
+      NO_THREAD_SAFETY_ANALYSIS;  // Reading lock owner without holding lock is racy.
 
-  static void MonitorEnter(Thread* thread, Object* obj);
-  static bool MonitorExit(Thread* thread, Object* obj);
+  static void MonitorEnter(Thread* thread, Object* obj)
+      EXCLUSIVE_LOCK_FUNCTION(monitor_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static bool MonitorExit(Thread* thread, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      UNLOCK_FUNCTION(monitor_lock_);
 
-  static void Notify(Thread* self, Object* obj);
-  static void NotifyAll(Thread* self, Object* obj);
-  static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow);
+  static void Notify(Thread* self, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void NotifyAll(Thread* self, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static void DescribeWait(std::ostream& os, const Thread* thread);
-  static void DescribeLocks(std::ostream& os, StackVisitor* stack_visitor);
+  static void DescribeWait(std::ostream& os, const Thread* thread)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void DescribeLocks(std::ostream& os, StackVisitor* stack_visitor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Object* GetObject();
 
  private:
-  explicit Monitor(Object* obj);
+  explicit Monitor(Thread* owner, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void AppendToWaitSet(Thread* thread);
-  void RemoveFromWaitSet(Thread* thread);
+  void AppendToWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
+  void RemoveFromWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
 
-  static void Inflate(Thread* self, Object* obj);
+  static void Inflate(Thread* self, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent, const char* owner_filename, uint32_t owner_line_number);
+  void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
+                          const char* owner_filename, uint32_t owner_line_number)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static void FailedUnlock(Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon);
+  static void FailedUnlock(Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Lock(Thread* self) NO_THREAD_SAFETY_ANALYSIS; // TODO: mark Object LOCKABLE.
-  bool Unlock(Thread* thread) NO_THREAD_SAFETY_ANALYSIS; // TODO: mark Object LOCKABLE.
+  void Lock(Thread* self) EXCLUSIVE_LOCK_FUNCTION(monitor_lock_);
+  bool Unlock(Thread* thread, bool for_wait) UNLOCK_FUNCTION(monitor_lock_);
 
-  void Notify(Thread* self);
-  void NotifyAll(Thread* self);
+  void Notify(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
+  void NotifyWithLock()
+      EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow) NO_THREAD_SAFETY_ANALYSIS; // TODO: mark Object LOCKABLE.
+  void NotifyAll(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
+  void NotifyAllWithLock()
+      EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+
+  void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow)
+      NO_THREAD_SAFETY_ANALYSIS;
+  void WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow)
+      EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Translates the provided method and pc into its declaring class' source file and line number.
   void TranslateLocation(const Method* method, uint32_t pc,
-                         const char*& source_file, uint32_t& line_number) const;
+                         const char*& source_file, uint32_t& line_number) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static bool (*is_sensitive_thread_hook_)();
   static uint32_t lock_profiling_threshold_;
 
+  Mutex monitor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+
   // Which thread currently owns the lock?
   Thread* volatile owner_;
 
   // Owner's recursive lock depth.
-  int lock_count_;
+  int lock_count_ GUARDED_BY(monitor_lock_);
 
   // What object are we part of (for debugging).
   Object* const obj_;
 
   // Threads currently waiting on this monitor.
-  Thread* wait_set_;
-
-  Mutex lock_;
+  Thread* wait_set_ GUARDED_BY(monitor_lock_);
 
   // Method and dex pc where the lock owner acquired the lock, used when lock
   // sampling is enabled. locking_method_ may be null if the lock is currently
   // unlocked, or if the lock is acquired by the system when the stack is empty.
-  const Method* locking_method_;
-  uint32_t locking_dex_pc_;
+  const Method* locking_method_ GUARDED_BY(monitor_lock_);
+  uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
 
   friend class MonitorList;
   friend class Object;
@@ -140,11 +171,12 @@
 
   void Add(Monitor* m);
 
-  void SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg);
+  void SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_);
 
  private:
-  Mutex lock_;
-  std::list<Monitor*> list_;
+  Mutex monitor_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  std::list<Monitor*> list_ GUARDED_BY(monitor_list_lock_);
 
   DISALLOW_COPY_AND_ASSIGN(MonitorList);
 };
diff --git a/src/monitor_android.cc b/src/monitor_android.cc
index 94f86e8..ce42ee7 100644
--- a/src/monitor_android.cc
+++ b/src/monitor_android.cc
@@ -50,7 +50,8 @@
   return dst + len;
 }
 
-void Monitor::LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent, const char* owner_filename, uint32_t owner_line_number) {
+void Monitor::LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
+                                 const char* owner_filename, uint32_t owner_line_number) {
   // Emit the event list length, 1 byte.
   char eventBuffer[174];
   char* cp = eventBuffer;
@@ -103,7 +104,8 @@
   cp = EventLogWriteInt(cp, sample_percent);
 
   CHECK_LE((size_t)(cp - eventBuffer), sizeof(eventBuffer));
-  android_btWriteLog(EVENT_LOG_TAG_dvm_lock_sample, EVENT_TYPE_LIST, eventBuffer, (size_t)(cp - eventBuffer));
+  android_btWriteLog(EVENT_LOG_TAG_dvm_lock_sample, EVENT_TYPE_LIST, eventBuffer,
+                     (size_t)(cp - eventBuffer));
 }
 
 }  // namespace art
diff --git a/src/mutex.cc b/src/mutex.cc
index c5551bd..182f6f0 100644
--- a/src/mutex.cc
+++ b/src/mutex.cc
@@ -37,44 +37,158 @@
 
 // This works on Mac OS 10.7, but hasn't been tested on older releases.
 struct __attribute__((__may_alias__)) darwin_pthread_mutex_t {
-  uint32_t padding0[2];
-  uint32_t value;
-  uint32_t padding1[5];
-  uint64_t owner_tid;
+  uint32_t padding0[4];
+  intptr_t padding1;
+  uintptr_t owner_tid;
+  // ...other stuff we don't care about.
+};
+
+struct __attribute__((__may_alias__)) darwin_pthread_rwlock_t {
+  int32_t padding0[4];
+  intptr_t padding1[2];
+  uintptr_t rw_owner_tid;
   // ...other stuff we don't care about.
 };
 
 struct __attribute__((__may_alias__)) glibc_pthread_mutex_t {
-  int lock;
-  unsigned int count;
+  int32_t padding0[2];
   int owner;
   // ...other stuff we don't care about.
 };
 
-static inline void CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking) {
-  if (!kIsDebugBuild) {
-    return;
+struct __attribute__((__may_alias__)) glibc_pthread_rwlock_t {
+#ifdef __LP64__
+  int32_t padding0[6];
+#else
+  int32_t padding0[7];
+#endif
+  int writer;
+  // ...other stuff we don't care about.
+};
+
+ReaderWriterMutex* GlobalSynchronization::mutator_lock_ = NULL;
+Mutex* GlobalSynchronization::thread_list_lock_ = NULL;
+Mutex* GlobalSynchronization::classlinker_classes_lock_ = NULL;
+ReaderWriterMutex* GlobalSynchronization::heap_bitmap_lock_ = NULL;
+Mutex* GlobalSynchronization::abort_lock_ = NULL;
+Mutex* GlobalSynchronization::logging_lock_ = NULL;
+Mutex* GlobalSynchronization::unexpected_signal_lock_ = NULL;
+Mutex* GlobalSynchronization::thread_suspend_count_lock_ = NULL;
+
+void GlobalSynchronization::Init() {
+  if (logging_lock_ != NULL) {
+    // Already initialized.
+    DCHECK(mutator_lock_ != NULL);
+    DCHECK(thread_list_lock_ != NULL);
+    DCHECK(classlinker_classes_lock_ != NULL);
+    DCHECK(heap_bitmap_lock_ != NULL);
+    DCHECK(abort_lock_ != NULL);
+    DCHECK(logging_lock_ != NULL);
+    DCHECK(unexpected_signal_lock_ != NULL);
+    DCHECK(thread_suspend_count_lock_ != NULL);
+  } else {
+    logging_lock_ = new Mutex("logging lock", kLoggingLock, true);
+    abort_lock_ = new Mutex("abort lock", kAbortLock, true);
+    DCHECK(mutator_lock_ == NULL);
+    mutator_lock_ = new ReaderWriterMutex("mutator lock", kMutatorLock);
+    DCHECK(thread_list_lock_ == NULL);
+    thread_list_lock_ = new Mutex("thread list lock", kThreadListLock);
+    DCHECK(classlinker_classes_lock_ == NULL);
+    classlinker_classes_lock_ = new Mutex("ClassLinker classes lock", kClassLinkerClassesLock);
+    DCHECK(heap_bitmap_lock_ == NULL);
+    heap_bitmap_lock_ = new ReaderWriterMutex("heap bitmap lock", kHeapBitmapLock);
+    DCHECK(unexpected_signal_lock_ == NULL);
+    unexpected_signal_lock_ = new Mutex("unexpected signal lock", kUnexpectedSignalLock, true);
+    DCHECK(thread_suspend_count_lock_ == NULL);
+    thread_suspend_count_lock_ = new Mutex("thread suspend count lock", kThreadSuspendCountLock);
   }
-  if (rank == -1) {
-    return;
-  }
-  Thread::Current()->CheckSafeToLockOrUnlock(rank, is_locking);
 }
 
-static inline void CheckSafeToWait(MutexRank rank) {
-  if (!kIsDebugBuild) {
-    return;
-  }
-  Thread::Current()->CheckSafeToWait(rank);
+BaseMutex::BaseMutex(const char* name, MutexLevel level) : level_(level), name_(name) {}
+
+static void CheckUnattachedThread(MutexLevel level) {
+  // The check below enumerates the cases where we expect not to be able to sanity check locks
+  // on a thread. TODO: tighten this check.
+  Runtime* runtime = Runtime::Current();
+  CHECK(runtime == NULL || !runtime->IsStarted() || runtime->IsShuttingDown() ||
+        level == kDefaultMutexLevel  || level == kThreadListLock ||
+        level == kLoggingLock || level == kAbortLock);
 }
 
-Mutex::Mutex(const char* name, MutexRank rank) : name_(name), rank_(rank) {
-  // Like Java, we use recursive mutexes.
+void BaseMutex::RegisterAsLockedWithCurrentThread() {
+  Thread* self = Thread::Current();
+  if (self == NULL) {
+    CheckUnattachedThread(level_);
+    return;
+  }
+  // Check if a bad Mutex of this level or lower is held.
+  bool bad_mutexes_held = false;
+  for (int i = level_; i >= 0; --i) {
+    BaseMutex* held_mutex = self->GetHeldMutex(static_cast<MutexLevel>(i));
+    if (UNLIKELY(held_mutex != NULL)) {
+      LOG(ERROR) << "Lock level violation: holding \"" << held_mutex->name_ << "\" (level " << i
+          << ") while locking \"" << name_ << "\" (level " << static_cast<int>(level_) << ")";
+      if (i > kAbortLock) {
+        // Only abort in the check below if this is more than abort level lock.
+        bad_mutexes_held = true;
+      }
+    }
+  }
+  CHECK(!bad_mutexes_held);
+  // Don't record monitors as they are outside the scope of analysis. They may be inspected off of
+  // the monitor list.
+  if (level_ != kMonitorLock) {
+    self->SetHeldMutex(level_, this);
+  }
+}
+
+void BaseMutex::RegisterAsUnlockedWithCurrentThread() {
+  Thread* self = Thread::Current();
+  if (self == NULL) {
+    CheckUnattachedThread(level_);
+    return;
+  }
+  if (level_ != kMonitorLock) {
+    CHECK(self->GetHeldMutex(level_) == this) << "Unlocking on unacquired mutex: " << name_;
+    self->SetHeldMutex(level_, NULL);
+  }
+}
+
+void BaseMutex::CheckSafeToWait() {
+  Thread* self = Thread::Current();
+  if (self == NULL) {
+    CheckUnattachedThread(level_);
+    return;
+  }
+  CHECK(self->GetHeldMutex(level_) == this) << "Waiting on unacquired mutex: " << name_;
+  bool bad_mutexes_held = false;
+  for (int i = kMaxMutexLevel; i >= 0; --i) {
+    if (i != level_) {
+      BaseMutex* held_mutex = self->GetHeldMutex(static_cast<MutexLevel>(i));
+      if (held_mutex != NULL) {
+        LOG(ERROR) << "Holding " << held_mutex->name_ << " (level " << i
+            << ") while performing wait on: "
+            << name_ << " (level " << static_cast<int>(level_) << ")";
+        bad_mutexes_held = true;
+      }
+    }
+  }
+  CHECK(!bad_mutexes_held);
+}
+
+Mutex::Mutex(const char* name, MutexLevel level, bool recursive)
+    : BaseMutex(name, level), recursive_(recursive), recursion_count_(0) {
+#if defined(__BIONIC__)
+  // Use recursive mutexes as Bionic's non-recursive mutexes don't have TIDs to check lock
+  // ownership of.
   pthread_mutexattr_t attributes;
   CHECK_MUTEX_CALL(pthread_mutexattr_init, (&attributes));
   CHECK_MUTEX_CALL(pthread_mutexattr_settype, (&attributes, PTHREAD_MUTEX_RECURSIVE));
   CHECK_MUTEX_CALL(pthread_mutex_init, (&mutex_, &attributes));
   CHECK_MUTEX_CALL(pthread_mutexattr_destroy, (&attributes));
+#else
+  CHECK_MUTEX_CALL(pthread_mutex_init, (&mutex_, NULL));
+#endif
 }
 
 Mutex::~Mutex() {
@@ -89,55 +203,69 @@
   }
 }
 
-void Mutex::Lock() {
-  CheckSafeToLockOrUnlock(rank_, true);
-  CHECK_MUTEX_CALL(pthread_mutex_lock, (&mutex_));
+void Mutex::ExclusiveLock() {
+  bool is_held = IsExclusiveHeld();
+  CHECK(recursive_ || !is_held)
+      << "Error attempt to recursively lock non-recursive lock \"" << name_ << "\"";
+  if (!is_held) {
+    CHECK_MUTEX_CALL(pthread_mutex_lock, (&mutex_));
+    RegisterAsLockedWithCurrentThread();
+  }
+  recursion_count_++;
+  DCHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
+      << name_ << " " << recursion_count_;
   AssertHeld();
 }
 
-bool Mutex::TryLock() {
-  int result = pthread_mutex_trylock(&mutex_);
-  if (result == EBUSY) {
-    return false;
+bool Mutex::ExclusiveTryLock() {
+  bool is_held = IsExclusiveHeld();
+  CHECK(recursive_ || !is_held)
+      << "Error attempt to recursively lock non-recursive lock \"" << name_ << "\"";
+  if (!is_held) {
+    int result = pthread_mutex_trylock(&mutex_);
+    if (result == EBUSY) {
+      return false;
+    }
+    if (result != 0) {
+      errno = result;
+      PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
+    }
+    RegisterAsLockedWithCurrentThread();
   }
-  if (result != 0) {
-    errno = result;
-    PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
-  }
-  CheckSafeToLockOrUnlock(rank_, true);
+  recursion_count_++;
   AssertHeld();
   return true;
 }
 
-void Mutex::Unlock() {
+void Mutex::ExclusiveUnlock() {
   AssertHeld();
-  CheckSafeToLockOrUnlock(rank_, false);
-  CHECK_MUTEX_CALL(pthread_mutex_unlock, (&mutex_));
+  recursion_count_--;
+  if (!recursive_ || recursion_count_ == 0) {
+    DCHECK(recursion_count_ == 0 || recursive_) << "Unexpected recursion count on mutex: "
+        << name_ << " " << recursion_count_;
+    RegisterAsUnlockedWithCurrentThread();
+    CHECK_MUTEX_CALL(pthread_mutex_unlock, (&mutex_));
+  }
 }
 
-#if !defined(NDEBUG)
-#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED < 1060
-// Mac OS 10.5 didn't have anything we could implement GetTid() with. One thing we could try would
-// be using pthread_t instead of the actual tid; this would be acceptable in most places, and more
-// portable. 10.5 is already obsolete, though, so doing so would probably be all pain for no gain.
-void Mutex::AssertHeld() {}
-void Mutex::AssertNotHeld() {}
-#else
-void Mutex::AssertHeld() {
-  DCHECK_EQ(GetOwner(), static_cast<uint64_t>(GetTid()));
+bool Mutex::IsExclusiveHeld() const {
+  Thread* self = Thread::Current();
+  bool result;
+  if (self == NULL || level_ == kMonitorLock) {  // Handle unattached threads and monitors.
+    result = (GetExclusiveOwnerTid() == static_cast<uint64_t>(GetTid()));
+  } else {
+    result = (self->GetHeldMutex(level_) == this);
+    // Sanity debug check that if we think it is locked, so does the pthread.
+    DCHECK(result == (GetExclusiveOwnerTid() == static_cast<uint64_t>(GetTid())));
+  }
+  return result;
 }
 
-void Mutex::AssertNotHeld() {
-  DCHECK_NE(GetOwner(), static_cast<uint64_t>(GetTid()));
-}
-#endif
-#endif
-
-uint64_t Mutex::GetOwner() {
+uint64_t Mutex::GetExclusiveOwnerTid() const {
 #if defined(__BIONIC__)
   return static_cast<uint64_t>((mutex_.value >> 16) & 0xffff);
 #elif defined(__GLIBC__)
-  return reinterpret_cast<glibc_pthread_mutex_t*>(&mutex_)->owner;
+  return reinterpret_cast<const glibc_pthread_mutex_t*>(&mutex_)->owner;
 #elif defined(__APPLE__)
   return reinterpret_cast<darwin_pthread_mutex_t*>(&mutex_)->owner_tid;
 #else
@@ -145,24 +273,104 @@
 #endif
 }
 
-uint32_t Mutex::GetDepth() {
-  bool held = (GetOwner() == static_cast<uint64_t>(GetTid()));
-  if (!held) {
-    return 0;
+ReaderWriterMutex::ReaderWriterMutex(const char* name, MutexLevel level) : BaseMutex(name, level) {
+  CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, NULL));
+}
+
+ReaderWriterMutex::~ReaderWriterMutex() {
+  // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
+  // may still be using locks.
+  int rc = pthread_rwlock_destroy(&rwlock_);
+  if (rc != 0) {
+    errno = rc;
+    // TODO: should we just not log at all if shutting down? this could be the logging mutex!
+    bool shutting_down = Runtime::Current()->IsShuttingDown();
+    PLOG(shutting_down ? WARNING : FATAL) << "pthread_mutex_destroy failed for " << name_;
   }
-  uint32_t depth;
+}
+
+void ReaderWriterMutex::ExclusiveLock() {
+  AssertNotExclusiveHeld();
+  CHECK_MUTEX_CALL(pthread_rwlock_wrlock, (&rwlock_));
+  RegisterAsLockedWithCurrentThread();
+  AssertExclusiveHeld();
+}
+
+void ReaderWriterMutex::ExclusiveUnlock() {
+  AssertExclusiveHeld();
+  RegisterAsUnlockedWithCurrentThread();
+  CHECK_MUTEX_CALL(pthread_rwlock_unlock, (&rwlock_));
+}
+
+bool ReaderWriterMutex::ExclusiveLockWithTimeout(const timespec& abs_timeout) {
+  int result = pthread_rwlock_timedwrlock(&rwlock_, &abs_timeout);
+  if (result == ETIMEDOUT) {
+    return false;
+  }
+  if (result != 0) {
+    errno = result;
+    PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
+  }
+  RegisterAsLockedWithCurrentThread();
+  AssertSharedHeld();
+  return true;
+}
+
+void ReaderWriterMutex::SharedLock() {
+  CHECK_MUTEX_CALL(pthread_rwlock_rdlock, (&rwlock_));
+  RegisterAsLockedWithCurrentThread();
+  AssertSharedHeld();
+}
+
+bool ReaderWriterMutex::SharedTryLock() {
+  int result = pthread_rwlock_tryrdlock(&rwlock_);
+  if (result == EBUSY) {
+    return false;
+  }
+  if (result != 0) {
+    errno = result;
+    PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
+  }
+  RegisterAsLockedWithCurrentThread();
+  AssertSharedHeld();
+  return true;
+}
+
+void ReaderWriterMutex::SharedUnlock() {
+  AssertSharedHeld();
+  RegisterAsUnlockedWithCurrentThread();
+  CHECK_MUTEX_CALL(pthread_rwlock_unlock, (&rwlock_));
+}
+
+bool ReaderWriterMutex::IsExclusiveHeld() const {
+  bool result = (GetExclusiveOwnerTid() == static_cast<uint64_t>(GetTid()));
+  // Sanity that if the pthread thinks we own the lock the Thread agrees.
+  Thread* self = Thread::Current();
+  DCHECK((self == NULL) || !result || (self->GetHeldMutex(level_) == this));
+  return result;
+}
+
+bool ReaderWriterMutex::IsSharedHeld() const {
+  Thread* self = Thread::Current();
+  bool result;
+  if (UNLIKELY(self == NULL)) {  // Handle unattached threads.
+    result = IsExclusiveHeld(); // TODO: a better best effort here.
+  } else {
+    result = (self->GetHeldMutex(level_) == this);
+  }
+  return result;
+}
+
+uint64_t ReaderWriterMutex::GetExclusiveOwnerTid() const {
 #if defined(__BIONIC__)
-  depth = static_cast<uint32_t>((mutex_.value >> 2) & 0x7ff) + 1;
+  return rwlock_.writerThreadId;
 #elif defined(__GLIBC__)
-  depth = reinterpret_cast<glibc_pthread_mutex_t*>(&mutex_)->count;
+  return reinterpret_cast<const glibc_pthread_rwlock_t*>(&rwlock_)->writer;
 #elif defined(__APPLE__)
-  darwin_pthread_mutex_t* darwin_mutex = reinterpret_cast<darwin_pthread_mutex_t*>(&mutex_);
-  depth = ((darwin_mutex->value >> 16) & 0xffff);
+  return reinterpret_cast<const darwin_pthread_rwlock_t*>(&rwlock_)->rw_owner_tid;
 #else
 #error unsupported C library
 #endif
-  CHECK_NE(depth, 0U) << "owner=" << GetOwner() << " tid=" << GetTid();
-  return depth;
 }
 
 ConditionVariable::ConditionVariable(const std::string& name) : name_(name) {
@@ -189,10 +397,11 @@
 }
 
 void ConditionVariable::Wait(Mutex& mutex) {
-  CheckSafeToWait(mutex.rank_);
-  uint unlock_depth = UnlockBeforeWait(mutex);
+  mutex.CheckSafeToWait();
+  unsigned int old_recursion_count = mutex.recursion_count_;
+  mutex.recursion_count_ = 0;
   CHECK_MUTEX_CALL(pthread_cond_wait, (&cond_, &mutex.mutex_));
-  RelockAfterWait(mutex, unlock_depth);
+  mutex.recursion_count_ = old_recursion_count;
 }
 
 void ConditionVariable::TimedWait(Mutex& mutex, const timespec& ts) {
@@ -201,32 +410,15 @@
 #else
 #define TIMEDWAIT pthread_cond_timedwait
 #endif
-  CheckSafeToWait(mutex.rank_);
-  uint unlock_depth = UnlockBeforeWait(mutex);
+  mutex.CheckSafeToWait();
+  unsigned int old_recursion_count = mutex.recursion_count_;
+  mutex.recursion_count_ = 0;
   int rc = TIMEDWAIT(&cond_, &mutex.mutex_, &ts);
-  RelockAfterWait(mutex, unlock_depth);
+  mutex.recursion_count_ = old_recursion_count;
   if (rc != 0 && rc != ETIMEDOUT) {
     errno = rc;
     PLOG(FATAL) << "TimedWait failed for " << name_;
   }
 }
 
-// Unlock a mutex down to depth == 1 so pthread conditional waiting can be used.
-// After waiting, use RelockAfterWait to restore the lock depth.
-uint32_t ConditionVariable::UnlockBeforeWait(Mutex& mutex) {
-  uint32_t unlock_count = 0;
-  CHECK_GT(mutex.GetDepth(), 0U);
-  while (mutex.GetDepth() != 1) {
-    mutex.Unlock();
-    unlock_count++;
-  }
-  return unlock_count;
-}
-
-void ConditionVariable::RelockAfterWait(Mutex& mutex, uint32_t unlock_count) {
-  for (uint32_t i = 0; i < unlock_count; i++) {
-    mutex.Lock();
-  }
-}
-
 }  // namespace art
diff --git a/src/mutex.h b/src/mutex.h
index 4c5d537..4899382 100644
--- a/src/mutex.h
+++ b/src/mutex.h
@@ -23,71 +23,316 @@
 #include <iosfwd>
 #include <string>
 
+#include "globals.h"
 #include "gtest/gtest.h"
 #include "logging.h"
 #include "macros.h"
 
 namespace art {
 
-enum MutexRank {
-  kNoMutexRank = -1,
-  kHeapLock = 0,
-  kThreadListLock = 1,
-  kThreadSuspendCountLock = 2,
-  kMaxMutexRank = kThreadSuspendCountLock,
-};
-std::ostream& operator<<(std::ostream& os, const MutexRank& rhs);
+class LOCKABLE Mutex;
+class LOCKABLE ReaderWriterMutex;
 
-class LOCKABLE Mutex {
+// MutexLevel is used to impose a lock hierarchy [1] where acquisition of a Mutex at a higher or
+// equal level to a lock a thread holds is invalid. The lock hierarchy achieves a cycle free
+// partial ordering and thereby cause deadlock situations to fail checks.
+//
+// [1] http://www.drdobbs.com/parallel/use-lock-hierarchies-to-avoid-deadlock/204801163
+enum MutexLevel {
+  kLoggingLock = 0,
+  kUnexpectedSignalLock = 1,
+  kThreadSuspendCountLock = 2,
+  kAbortLock = 3,
+  kDefaultMutexLevel = 4,
+  kLoadLibraryLock = 5,
+  kClassLinkerClassesLock = 6,
+  kThreadListLock = 7,
+  kHeapBitmapLock = 8,
+  kZygoteCreationLock = 9,
+  kMonitorLock = 10,
+  kMutatorLock = 11,
+  kMaxMutexLevel = kMutatorLock,
+};
+std::ostream& operator<<(std::ostream& os, const MutexLevel& rhs);
+
+// Global mutexes corresponding to the levels above.
+class GlobalSynchronization {
  public:
-  explicit Mutex(const char* name, MutexRank rank = kNoMutexRank);
+  static void Init();
+
+  // The mutator_lock_ is used to allow mutators to execute in a shared (reader) mode or to block
+  // mutators by having an exclusive (writer) owner. In normal execution each mutator thread holds
+  // a share on the mutator_lock_. The garbage collector may also execute with shared access but
+  // at times requires exclusive access to the heap (not to be confused with the heap meta-data
+  // guarded by the heap_lock_ below). When the garbage collector requires exclusive access it asks
+  // the mutators to suspend themselves which also involves usage of the thread_suspend_count_lock_
+  // to cover weaknesses in using ReaderWriterMutexes with ConditionVariables. We use a condition
+  // variable to wait upon in the suspension logic as releasing and then re-acquiring a share on
+  // the mutator lock doesn't necessarily allow the exclusive user (e.g the garbage collector)
+  // chance to acquire the lock.
+  //
+  // Thread suspension:
+  // Shared users                                  | Exclusive user
+  // (holding mutator lock and in kRunnable state) |   .. running ..
+  //   .. running ..                               | Request thread suspension by:
+  //   .. running ..                               |   - acquiring thread_suspend_count_lock_
+  //   .. running ..                               |   - incrementing Thread::suspend_count_ on
+  //   .. running ..                               |     all mutator threads
+  //   .. running ..                               |   - releasing thread_suspend_count_lock_
+  //   .. running ..                               | Block trying to acquire exclusive mutator lock
+  // Poll Thread::suspend_count_ and enter full    |   .. blocked ..
+  // suspend code.                                 |   .. blocked ..
+  // Change state to kSuspended                    |   .. blocked ..
+  // x: Release share on mutator_lock_             | Carry out exclusive access
+  // Acquire thread_suspend_count_lock_            |   .. exclusive ..
+  // while Thread::suspend_count_ > 0              |   .. exclusive ..
+  //   - wait on Thread::resume_cond_              |   .. exclusive ..
+  //     (releases thread_suspend_count_lock_)     |   .. exclusive ..
+  //   .. waiting ..                               | Release mutator_lock_
+  //   .. waiting ..                               | Request thread resumption by:
+  //   .. waiting ..                               |   - acquiring thread_suspend_count_lock_
+  //   .. waiting ..                               |   - decrementing Thread::suspend_count_ on
+  //   .. waiting ..                               |     all mutator threads
+  //   .. waiting ..                               |   - notifying on Thread::resume_cond_
+  //    - re-acquire thread_suspend_count_lock_    |   - releasing thread_suspend_count_lock_
+  // Release thread_suspend_count_lock_            |  .. running ..
+  // Acquire share on mutator_lock_                |  .. running ..
+  //  - This could block but the thread still      |  .. running ..
+  //    has a state of kSuspended and so this      |  .. running ..
+  //    isn't an issue.                            |  .. running ..
+  // Acquire thread_suspend_count_lock_            |  .. running ..
+  //  - we poll here as we're transitioning into   |  .. running ..
+  //    kRunnable and an individual thread suspend |  .. running ..
+  //    request (e.g for debugging) won't try      |  .. running ..
+  //    to acquire the mutator lock (which would   |  .. running ..
+  //    block as we hold the mutator lock). This   |  .. running ..
+  //    poll ensures that if the suspender thought |  .. running ..
+  //    we were suspended by incrementing our      |  .. running ..
+  //    Thread::suspend_count_ and then reading    |  .. running ..
+  //    our state we go back to waiting on         |  .. running ..
+  //    Thread::resume_cond_.                      |  .. running ..
+  // can_go_runnable = Thread::suspend_count_ == 0 |  .. running ..
+  // Release thread_suspend_count_lock_            |  .. running ..
+  // if can_go_runnable                            |  .. running ..
+  //   Change state to kRunnable                   |  .. running ..
+  // else                                          |  .. running ..
+  //   Goto x                                      |  .. running ..
+  //  .. running ..                                |  .. running ..
+  static ReaderWriterMutex* mutator_lock_;
+
+  // Allow reader-writer mutual exclusion on the mark and live bitmaps of the heap.
+  static ReaderWriterMutex* heap_bitmap_lock_ ACQUIRED_AFTER(mutator_lock_);
+
+  // The thread_list_lock_ guards ThreadList::list_. It is also commonly held to stop threads
+  // attaching and detaching.
+  static Mutex* thread_list_lock_ ACQUIRED_AFTER(heap_bitmap_lock_);
+
+  // Guards lists of classes within the class linker.
+  static Mutex* classlinker_classes_lock_ ACQUIRED_AFTER(thread_list_lock_);
+
+  // When declaring any Mutex add DEFAULT_MUTEX_ACQUIRED_AFTER to use annotalysis to check the code
+  // doesn't try to hold a higher level Mutex.
+  #define DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_AFTER(classlinker_classes_lock_)
+
+  // Have an exclusive aborting thread.
+  static Mutex* abort_lock_ ACQUIRED_AFTER(classlinker_classes_lock_);
+
+  // Allow mutual exclusion when manipulating Thread::suspend_count_.
+  // TODO: Does the trade-off of a per-thread lock make sense?
+  static Mutex* thread_suspend_count_lock_ ACQUIRED_AFTER(abort_lock_);
+
+  // One unexpected signal at a time lock.
+  static Mutex* unexpected_signal_lock_ ACQUIRED_AFTER(thread_suspend_count_lock_);
+
+  // Have an exclusive logging thread.
+  static Mutex* logging_lock_ ACQUIRED_AFTER(unexpected_signal_lock_);
+};
+
+// Base class for all Mutex implementations
+class BaseMutex {
+ public:
+  const std::string& GetName() const {
+    return name_;
+  }
+
+  virtual bool IsMutex() const { return false; }
+  virtual bool IsReaderWriterMutex() const { return false; }
+
+ protected:
+  friend class ConditionVariable;
+
+  BaseMutex(const char* name, MutexLevel level);
+  virtual ~BaseMutex() {}
+  void RegisterAsLockedWithCurrentThread();
+  void RegisterAsUnlockedWithCurrentThread();
+  void CheckSafeToWait();
+
+  const MutexLevel level_;  // Support for lock hierarchy.
+  const std::string name_;
+};
+
+// A Mutex is used to achieve mutual exclusion between threads. A Mutex can be used to gain
+// exclusive access to what it guards. A Mutex can be in one of two states:
+// - Free - not owned by any thread,
+// - Exclusive - owned by a single thread.
+//
+// The effect of locking and unlocking operations on the state is:
+// State     | ExclusiveLock | ExclusiveUnlock
+// -------------------------------------------
+// Free      | Exclusive     | error
+// Exclusive | Block*        | Free
+// * Mutex is not reentrant and so an attempt to ExclusiveLock on the same thread will result in
+//   an error. Being non-reentrant simplifies Waiting on ConditionVariables.
+class LOCKABLE Mutex : public BaseMutex {
+ public:
+  explicit Mutex(const char* name, MutexLevel level = kDefaultMutexLevel, bool recursive = false);
   ~Mutex();
 
-  void Lock() EXCLUSIVE_LOCK_FUNCTION();
+  virtual bool IsMutex() const { return true; }
 
-  bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
+  // Block until mutex is free then acquire exclusive access.
+  void ExclusiveLock() EXCLUSIVE_LOCK_FUNCTION();
+  void Lock() EXCLUSIVE_LOCK_FUNCTION() {  ExclusiveLock(); }
 
-  void Unlock() UNLOCK_FUNCTION();
+  // Returns true if acquires exclusive access, false otherwise.
+  bool ExclusiveTryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
+  bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true) { return ExclusiveTryLock(); }
 
-#if !defined(NDEBUG)
-  void AssertHeld();
-  void AssertNotHeld();
-#else
-  void AssertHeld() {}
-  void AssertNotHeld() {}
-#endif
+  // Release exclusive access.
+  void ExclusiveUnlock() UNLOCK_FUNCTION();
+  void Unlock() UNLOCK_FUNCTION() {  ExclusiveUnlock(); }
 
-  uint64_t GetOwner();
+  // Is the current thread the exclusive holder of the Mutex.
+  bool IsExclusiveHeld() const;
+
+  // Assert that the Mutex is exclusively held by the current thread.
+  void AssertExclusiveHeld() {
+    if (kIsDebugBuild) {
+      CHECK(IsExclusiveHeld());
+    }
+  }
+  void AssertHeld() { AssertExclusiveHeld(); }
+
+  // Assert that the Mutex is not held by the current thread.
+  void AssertNotHeldExclusive() {
+    if (kIsDebugBuild) {
+      CHECK(!IsExclusiveHeld());
+    }
+  }
+  void AssertNotHeld() { AssertNotHeldExclusive(); }
+
+  // Id associated with exclusive owner.
+  uint64_t GetExclusiveOwnerTid() const;
+
+  // Returns how many times this Mutex has been locked, it is better to use AssertHeld/NotHeld.
+  unsigned int GetDepth() const {
+    return recursion_count_;
+  }
 
  private:
-  uint32_t GetDepth();
-
   pthread_mutex_t mutex_;
-  const std::string name_;
-  const MutexRank rank_;
-
+  const bool recursive_;  // Can the lock be recursively held?
+  unsigned int recursion_count_;
   friend class ConditionVariable;
   friend class MutexTester;
   DISALLOW_COPY_AND_ASSIGN(Mutex);
 };
 
-class SCOPED_LOCKABLE MutexLock {
+// A ReaderWriterMutex is used to achieve mutual exclusion between threads, similar to a Mutex.
+// Unlike a Mutex a ReaderWriterMutex can be used to gain exclusive (writer) or shared (reader)
+// access to what it guards. A flaw in relation to a Mutex is that it cannot be used with a
+// condition variable. A ReaderWriterMutex can be in one of three states:
+// - Free - not owned by any thread,
+// - Exclusive - owned by a single thread,
+// - Shared(n) - shared amongst n threads.
+//
+// The effect of locking and unlocking operations on the state is:
+//
+// State     | ExclusiveLock | ExclusiveUnlock | SharedLock       | SharedUnlock
+// ----------------------------------------------------------------------------
+// Free      | Exclusive     | error           | SharedLock(1)    | error
+// Exclusive | Block         | Free            | Block            | error
+// Shared(n) | Block         | error           | SharedLock(n+1)* | Shared(n-1) or Free
+// * for large values of n the SharedLock may block.
+class LOCKABLE ReaderWriterMutex : public BaseMutex {
  public:
-  explicit MutexLock(Mutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
-    mu_.Lock();
+  explicit ReaderWriterMutex(const char* name, MutexLevel level = kDefaultMutexLevel);
+  ~ReaderWriterMutex();
+
+  virtual bool IsReaderWriterMutex() const { return true; }
+
+  // Block until ReaderWriterMutex is free then acquire exclusive access.
+  void ExclusiveLock() EXCLUSIVE_LOCK_FUNCTION();
+  void WriterLock() EXCLUSIVE_LOCK_FUNCTION() {  ExclusiveLock(); }
+
+  // Release exclusive access.
+  void ExclusiveUnlock() UNLOCK_FUNCTION();
+  void WriterUnlock() UNLOCK_FUNCTION() {  ExclusiveUnlock(); }
+
+  // Block until ReaderWriterMutex is free and acquire exclusive access. Returns true on success
+  // or false if timeout is reached.
+  bool ExclusiveLockWithTimeout(const timespec& abs_timeout) EXCLUSIVE_TRYLOCK_FUNCTION(true);
+
+  // Block until ReaderWriterMutex is shared or free then acquire a share on the access.
+  void SharedLock() SHARED_LOCK_FUNCTION();
+  void ReaderLock() SHARED_LOCK_FUNCTION() { SharedLock(); }
+
+  // Try to acquire share of ReaderWriterMutex.
+  bool SharedTryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
+
+  // Release a share of the access.
+  void SharedUnlock() UNLOCK_FUNCTION();
+  void ReaderUnlock() UNLOCK_FUNCTION() { SharedUnlock(); }
+
+  // Is the current thread the exclusive holder of the ReaderWriterMutex.
+  bool IsExclusiveHeld() const;
+
+  // Assert the current thread has exclusive access to the ReaderWriterMutex.
+  void AssertExclusiveHeld() {
+    if (kIsDebugBuild) {
+      CHECK(IsExclusiveHeld());
+    }
+  }
+  void AssertWriterHeld() { AssertExclusiveHeld(); }
+
+  // Assert the current thread doesn't have exclusive access to the ReaderWriterMutex.
+  void AssertNotExclusiveHeld() {
+    if (kIsDebugBuild) {
+      CHECK(!IsExclusiveHeld());
+    }
+  }
+  void AssertNotWriterHeld() { AssertNotExclusiveHeld(); }
+
+  // Is the current thread a shared holder of the ReaderWriterMutex.
+  bool IsSharedHeld() const;
+
+  // Assert the current thread has shared access to the ReaderWriterMutex.
+  void AssertSharedHeld() {
+    if (kIsDebugBuild) {
+      CHECK(IsSharedHeld());
+    }
+  }
+  void AssertReaderHeld() { AssertSharedHeld(); }
+
+  // Assert the current thread doesn't hold this ReaderWriterMutex either in shared or exclusive
+  // mode.
+  void AssertNotHeld() {
+    if (kIsDebugBuild) {
+      CHECK(!IsSharedHeld());
+    }
   }
 
-  ~MutexLock() UNLOCK_FUNCTION() {
-    mu_.Unlock();
-  }
-
+  // Id associated with exclusive owner.
+  uint64_t GetExclusiveOwnerTid() const;
  private:
-  Mutex& mu_;
-  DISALLOW_COPY_AND_ASSIGN(MutexLock);
-};
-// Catch bug where variable name is omitted. "MutexLock (lock);" instead of "MutexLock mu(lock)".
-#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_declaration_missing_variable_name)
+  pthread_rwlock_t rwlock_;
 
+  friend class MutexTester;
+  DISALLOW_COPY_AND_ASSIGN(ReaderWriterMutex);
+};
+
+// ConditionVariables allow threads to queue and sleep. Threads may then be resumed individually
+// (Signal) or all at once (Broadcast).
 class ConditionVariable {
  public:
   explicit ConditionVariable(const std::string& name);
@@ -99,14 +344,91 @@
   void TimedWait(Mutex& mutex, const timespec& ts);
 
  private:
-  uint32_t UnlockBeforeWait(Mutex& mutex) NO_THREAD_SAFETY_ANALYSIS;
-  void RelockAfterWait(Mutex& mutex, uint32_t unlock_count) NO_THREAD_SAFETY_ANALYSIS;
-
   pthread_cond_t cond_;
   std::string name_;
   DISALLOW_COPY_AND_ASSIGN(ConditionVariable);
 };
 
+// Scoped locker/unlocker for a regular Mutex that acquires mu upon construction and releases it
+// upon destruction.
+class SCOPED_LOCKABLE MutexLock {
+ public:
+  explicit MutexLock(Mutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_.ExclusiveLock();
+  }
+
+  ~MutexLock() UNLOCK_FUNCTION() {
+    mu_.ExclusiveUnlock();
+  }
+
+ private:
+  Mutex& mu_;
+  DISALLOW_COPY_AND_ASSIGN(MutexLock);
+};
+// Catch bug where variable name is omitted. "MutexLock (lock);" instead of "MutexLock mu(lock)".
+#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_declaration_missing_variable_name)
+
+// Scoped locker/unlocker for a ReaderWriterMutex that acquires read access to mu upon
+// construction and releases it upon destruction.
+class SCOPED_LOCKABLE ReaderMutexLock {
+ public:
+  explicit ReaderMutexLock(ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_.SharedLock();
+  }
+
+  ~ReaderMutexLock() UNLOCK_FUNCTION() {
+    mu_.SharedUnlock();
+  }
+
+ private:
+  ReaderWriterMutex& mu_;
+  DISALLOW_COPY_AND_ASSIGN(ReaderMutexLock);
+};
+// Catch bug where variable name is omitted. "ReaderMutexLock (lock);" instead of
+// "ReaderMutexLock mu(lock)".
+#define ReaderMutexLock(x) COMPILE_ASSERT(0, reader_mutex_lock_declaration_missing_variable_name)
+
+// Scoped locker/unlocker for a ReaderWriterMutex that acquires write access to mu upon
+// construction and releases it upon destruction.
+class SCOPED_LOCKABLE WriterMutexLock {
+ public:
+  explicit WriterMutexLock(ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+    mu_.ExclusiveLock();
+  }
+
+  ~WriterMutexLock() UNLOCK_FUNCTION() {
+    mu_.ExclusiveUnlock();
+  }
+
+ private:
+  ReaderWriterMutex& mu_;
+  DISALLOW_COPY_AND_ASSIGN(WriterMutexLock);
+};
+// Catch bug where variable name is omitted. "WriterMutexLock (lock);" instead of
+// "WriterMutexLock mu(lock)".
+#define WriterMutexLock(x) COMPILE_ASSERT(0, writer_mutex_lock_declaration_missing_variable_name)
+
+// Scoped unlocker/locker for a ReaderWriterMutex that releases read access to mu upon
+// construction and acquires it again upon destruction.
+class ReaderMutexUnlock {
+ public:
+  explicit ReaderMutexUnlock(ReaderWriterMutex& mu) UNLOCK_FUNCTION(mu) : mu_(mu) {
+    mu_.SharedUnlock();
+  }
+
+  ~ReaderMutexUnlock() SHARED_LOCK_FUNCTION(mu_) {
+    mu_.SharedLock();
+  }
+
+ private:
+  ReaderWriterMutex& mu_;
+  DISALLOW_COPY_AND_ASSIGN(ReaderMutexUnlock);
+};
+// Catch bug where variable name is omitted. "ReaderMutexUnlock (lock);" instead of
+// "ReaderMutexUnlock mu(lock)".
+#define ReaderMutexUnlock(x) \
+    COMPILE_ASSERT(0, reader_mutex_unlock_declaration_missing_variable_name)
+
 }  // namespace art
 
 #endif  // ART_SRC_MUTEX_H_
diff --git a/src/mutex_test.cc b/src/mutex_test.cc
index 69507d1..8a40cd6 100644
--- a/src/mutex_test.cc
+++ b/src/mutex_test.cc
@@ -60,7 +60,7 @@
 
 // GCC has trouble with our mutex tests, so we have to turn off thread safety analysis.
 static void RecursiveLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
-  Mutex mu("test mutex");
+  Mutex mu("test mutex", kDefaultMutexLevel, true);
   MutexTester::AssertDepth(mu, 0U);
   mu.Lock();
   MutexTester::AssertDepth(mu, 1U);
@@ -78,7 +78,7 @@
 
 // GCC has trouble with our mutex tests, so we have to turn off thread safety analysis.
 static void RecursiveTryLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
-  Mutex mu("test mutex");
+  Mutex mu("test mutex", kDefaultMutexLevel, true);
   MutexTester::AssertDepth(mu, 0U);
   ASSERT_TRUE(mu.TryLock());
   MutexTester::AssertDepth(mu, 1U);
@@ -96,7 +96,9 @@
 
 
 struct RecursiveLockWait {
-  explicit RecursiveLockWait() : mu("test mutex"), cv("test condition variable") {}
+  explicit RecursiveLockWait()
+      : mu("test mutex", kDefaultMutexLevel, true), cv("test condition variable") {
+  }
 
   static void* Callback(void* arg) {
     RecursiveLockWait* state = reinterpret_cast<RecursiveLockWait*>(arg);
@@ -132,4 +134,38 @@
   RecursiveLockWaitTest();
 }
 
+TEST_F(MutexTest, SharedLockUnlock) {
+  ReaderWriterMutex mu("test rwmutex");
+  mu.AssertNotHeld();
+  mu.SharedLock();
+  mu.AssertSharedHeld();
+  mu.AssertNotExclusiveHeld();
+  mu.SharedUnlock();
+  mu.AssertNotHeld();
+}
+
+TEST_F(MutexTest, ExclusiveLockUnlock) {
+  ReaderWriterMutex mu("test rwmutex");
+  mu.AssertNotHeld();
+  mu.ExclusiveLock();
+  mu.AssertSharedHeld();
+  mu.AssertExclusiveHeld();
+  mu.ExclusiveUnlock();
+  mu.AssertNotHeld();
+}
+
+// GCC has trouble with our mutex tests, so we have to turn off thread safety analysis.
+static void SharedTryLockUnlockTest() NO_THREAD_SAFETY_ANALYSIS {
+  ReaderWriterMutex mu("test rwmutex");
+  mu.AssertNotHeld();
+  ASSERT_TRUE(mu.SharedTryLock());
+  mu.AssertSharedHeld();
+  mu.SharedUnlock();
+  mu.AssertNotHeld();
+}
+
+TEST_F(MutexTest, SharedTryLockUnlock) {
+  SharedTryLockUnlockTest();
+}
+
 }  // namespace art
diff --git a/src/native/dalvik_system_DexFile.cc b/src/native/dalvik_system_DexFile.cc
index 3e749e5..30f411c 100644
--- a/src/native/dalvik_system_DexFile.cc
+++ b/src/native/dalvik_system_DexFile.cc
@@ -24,7 +24,7 @@
 #include "logging.h"
 #include "os.h"
 #include "runtime.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
 #include "space.h"
@@ -89,12 +89,14 @@
   if (env->ExceptionCheck()) {
     return 0;
   }
+  ScopedObjectAccess soa(env);
   const DexFile* dex_file;
   if (outputName.c_str() == NULL) {
     dex_file = Runtime::Current()->GetClassLinker()->FindDexFileInOatFileFromDexLocation(source);
   } else {
     std::string output(outputName.c_str());
-    dex_file = Runtime::Current()->GetClassLinker()->FindOrCreateOatFileForDexLocation(source, output);
+    dex_file =
+        Runtime::Current()->GetClassLinker()->FindOrCreateOatFileForDexLocation(source, output);
   }
   if (dex_file == NULL) {
     LOG(WARNING) << "Failed to open dex file: " << source;
@@ -105,7 +107,8 @@
   return static_cast<jint>(reinterpret_cast<uintptr_t>(dex_file));
 }
 
-static const DexFile* toDexFile(int dex_file_address) {
+static const DexFile* toDexFile(int dex_file_address)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   const DexFile* dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(dex_file_address));
   if (dex_file == NULL) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/NullPointerException;", "dex_file == null");
@@ -113,8 +116,12 @@
   return dex_file;
 }
 
-static void DexFile_closeDexFile(JNIEnv*, jclass, jint cookie) {
-  const DexFile* dex_file = toDexFile(cookie);
+static void DexFile_closeDexFile(JNIEnv* env, jclass, jint cookie) {
+  const DexFile* dex_file;
+  {
+    ScopedObjectAccess soa(env);
+    dex_file = toDexFile(cookie);
+  }
   if (dex_file == NULL) {
     return;
   }
@@ -126,7 +133,7 @@
 
 static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
                                         jint cookie) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   const DexFile* dex_file = toDexFile(cookie);
   if (dex_file == NULL) {
     return NULL;
@@ -142,14 +149,18 @@
   }
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   class_linker->RegisterDexFile(*dex_file);
-  Object* class_loader_object = ts.Decode<Object*>(javaLoader);
+  Object* class_loader_object = soa.Decode<Object*>(javaLoader);
   ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
   Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
-  return ts.AddLocalReference<jclass>(result);
+  return soa.AddLocalReference<jclass>(result);
 }
 
 static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jint cookie) {
-  const DexFile* dex_file = toDexFile(cookie);
+  const DexFile* dex_file;
+  {
+    ScopedObjectAccess soa(env);
+    dex_file = toDexFile(cookie);
+  }
   if (dex_file == NULL) {
     return NULL;
   }
@@ -174,6 +185,7 @@
 
   if (!OS::FileExists(filename.c_str())) {
     LOG(ERROR) << "DexFile_isDexOptNeeded file '" << filename.c_str() << "' does not exist";
+    ScopedObjectAccess soa(env);
     Thread::Current()->ThrowNewExceptionF("Ljava/io/FileNotFoundException;", "%s", filename.c_str());
     return JNI_TRUE;
   }
@@ -205,6 +217,7 @@
       }
       return JNI_FALSE;
     }
+    ScopedObjectAccess soa(env);
     if (ClassLinker::VerifyOatFileChecksums(oat_file.get(), filename.c_str(), location_checksum)) {
       if (debug_logging) {
         LOG(INFO) << "DexFile_isDexOptNeeded precompiled file " << oat_filename
@@ -232,6 +245,7 @@
       // TODO: Ensure this works with multiple image spaces.
       const ImageHeader& image_header = (*cur)->AsImageSpace()->GetImageHeader();
       if (oat_file->GetOatHeader().GetImageFileLocationChecksum() != image_header.GetOatChecksum()) {
+        ScopedObjectAccess soa(env);
         LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
                   << " has out-of-date checksum compared to "
                   << image_header.GetImageRoot(ImageHeader::kOatLocation)->AsString()->ToModifiedUtf8();
@@ -246,9 +260,10 @@
     return JNI_TRUE;
   }
 
+  ScopedObjectAccess soa(env);
   if (!ClassLinker::VerifyOatFileChecksums(oat_file.get(), filename.c_str(), location_checksum)) {
     LOG(INFO) << "DexFile_isDexOptNeeded cache file " << cache_location
-              << " has out-of-date checksum compared to " << filename.c_str();
+        << " has out-of-date checksum compared to " << filename.c_str();
     return JNI_TRUE;
   }
 
diff --git a/src/native/dalvik_system_VMDebug.cc b/src/native/dalvik_system_VMDebug.cc
index 70067fe..3799bbe 100644
--- a/src/native/dalvik_system_VMDebug.cc
+++ b/src/native/dalvik_system_VMDebug.cc
@@ -22,7 +22,7 @@
 #include "hprof/hprof.h"
 #include "jni_internal.h"
 #include "ScopedUtfChars.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "toStringArray.h"
 #include "trace.h"
 
@@ -57,7 +57,8 @@
   Trace::Start("[DDMS]", -1, bufferSize, flags, true);
 }
 
-static void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename, jobject javaFd, jint bufferSize, jint flags) {
+static void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename,
+                                         jobject javaFd, jint bufferSize, jint flags) {
   int originalFd = jniGetFDFromFileDescriptor(env, javaFd);
   if (originalFd < 0) {
     return;
@@ -65,7 +66,9 @@
 
   int fd = dup(originalFd);
   if (fd < 0) {
-    Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;", "dup(%d) failed: %s", originalFd, strerror(errno));
+    ScopedObjectAccess soa(env);
+    Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
+                                          "dup(%d) failed: %s", originalFd, strerror(errno));
     return;
   }
 
@@ -76,7 +79,8 @@
   Trace::Start(traceFilename.c_str(), fd, bufferSize, flags, false);
 }
 
-static void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename, jint bufferSize, jint flags) {
+static void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename,
+                                               jint bufferSize, jint flags) {
   ScopedUtfChars traceFilename(env, javaTraceFilename);
   if (traceFilename.c_str() == NULL) {
     return;
@@ -114,23 +118,28 @@
   return Dbg::LastDebuggerActivity();
 }
 
-static void VMDebug_startInstructionCounting(JNIEnv*, jclass) {
+static void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   Thread::Current()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", "");
 }
 
-static void VMDebug_stopInstructionCounting(JNIEnv*, jclass) {
+static void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   Thread::Current()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", "");
 }
 
-static void VMDebug_getInstructionCount(JNIEnv*, jclass, jintArray /*javaCounts*/) {
+static void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray /*javaCounts*/) {
+  ScopedObjectAccess soa(env);
   Thread::Current()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", "");
 }
 
-static void VMDebug_resetInstructionCount(JNIEnv*, jclass) {
+static void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   Thread::Current()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", "");
 }
 
-static void VMDebug_printLoadedClasses(JNIEnv*, jclass, jint flags) {
+static void VMDebug_printLoadedClasses(JNIEnv* env, jclass, jint flags) {
+  ScopedObjectAccess soa(env);
   return Runtime::Current()->GetClassLinker()->DumpAllClasses(flags);
 }
 
@@ -155,7 +164,9 @@
 static void VMDebug_dumpHprofData(JNIEnv* env, jclass, jstring javaFilename, jobject javaFd) {
   // Only one of these may be NULL.
   if (javaFilename == NULL && javaFd == NULL) {
-    Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "fileName == null && fd == null");
+    ScopedObjectAccess soa(env);
+    Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;",
+                                         "fileName == null && fd == null");
     return;
   }
 
@@ -174,7 +185,9 @@
   if (javaFd != NULL) {
     fd = jniGetFDFromFileDescriptor(env, javaFd);
     if (fd < 0) {
-      Thread::Current()->ThrowNewException("Ljava/lang/RuntimeException;", "Invalid file descriptor");
+      ScopedObjectAccess soa(env);
+      Thread::Current()->ThrowNewException("Ljava/lang/RuntimeException;",
+                                           "Invalid file descriptor");
       return;
     }
   }
@@ -187,11 +200,11 @@
 }
 
 static void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   LOG(INFO) << "--- reference table dump ---";
 
-  JNIEnvExt* e = reinterpret_cast<JNIEnvExt*>(env);
-  e->DumpReferenceTables(LOG(INFO));
-  e->vm->DumpReferenceTables(LOG(INFO));
+  soa.Env()->DumpReferenceTables(LOG(INFO));
+  soa.Vm()->DumpReferenceTables(LOG(INFO));
 
   LOG(INFO) << "---";
 }
@@ -204,9 +217,10 @@
   LOG(INFO) << "VMDebug infopoint " << id << " hit";
 }
 
-static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass, jboolean countAssignable) {
-  ScopedJniThreadState ts(env);
-  Class* c = ts.Decode<Class*>(javaClass);
+static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass,
+                                           jboolean countAssignable) {
+  ScopedObjectAccess soa(env);
+  Class* c = soa.Decode<Class*>(javaClass);
   if (c == NULL) {
     return 0;
   }
diff --git a/src/native/dalvik_system_VMRuntime.cc b/src/native/dalvik_system_VMRuntime.cc
index 4ec1b92..8dbbc77 100644
--- a/src/native/dalvik_system_VMRuntime.cc
+++ b/src/native/dalvik_system_VMRuntime.cc
@@ -21,9 +21,7 @@
 #include "jni_internal.h"
 #include "object.h"
 #include "object_utils.h"
-#include "scoped_heap_lock.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "thread.h"
 #include "thread_list.h"
@@ -49,7 +47,7 @@
 }
 
 static jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaElementClass, jint length) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
 #ifdef MOVING_GARBAGE_COLLECTOR
   // TODO: right now, we don't have a copying collector, so there's no need
   // to do anything special here, but we ought to pass the non-movability
@@ -57,7 +55,7 @@
   UNIMPLEMENTED(FATAL);
 #endif
 
-  Class* element_class = ts.Decode<Class*>(javaElementClass);
+  Class* element_class = soa.Decode<Class*>(javaElementClass);
   if (element_class == NULL) {
     Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "element class == null");
     return NULL;
@@ -76,15 +74,15 @@
   if (result == NULL) {
     return NULL;
   }
-  return ts.AddLocalReference<jobject>(result);
+  return soa.AddLocalReference<jobject>(result);
 }
 
 static jlong VMRuntime_addressOf(JNIEnv* env, jobject, jobject javaArray) {
   if (javaArray == NULL) {  // Most likely allocation failed
     return 0;
   }
-  ScopedJniThreadState ts(env);
-  Array* array = ts.Decode<Array*>(javaArray);
+  ScopedObjectAccess soa(env);
+  Array* array = soa.Decode<Array*>(javaArray);
   if (!array->IsArrayInstance()) {
     Thread::Current()->ThrowNewException("Ljava/lang/IllegalArgumentException;", "not an array");
     return 0;
@@ -143,7 +141,7 @@
 #if !defined(ART_USE_LLVM_COMPILER)
     if (vm->check_jni) {
       LOG(WARNING) << "Turning off CheckJNI so we can turn on JNI app bug workarounds...";
-      ScopedThreadListLock thread_list_lock;
+      MutexLock mu(*GlobalSynchronization::thread_list_lock_);
       vm->SetCheckJniEnabled(false);
       runtime->GetThreadList()->ForEach(DisableCheckJniCallback, NULL);
     }
@@ -160,8 +158,6 @@
 }
 
 static void VMRuntime_trimHeap(JNIEnv*, jobject) {
-  ScopedHeapLock heap_lock;
-
   // Trim the managed heap.
   Heap* heap = Runtime::Current()->GetHeap();
   const Spaces& spaces = heap->GetSpaces();
diff --git a/src/native/dalvik_system_VMStack.cc b/src/native/dalvik_system_VMStack.cc
index 12fa8db..3284c97 100644
--- a/src/native/dalvik_system_VMStack.cc
+++ b/src/native/dalvik_system_VMStack.cc
@@ -18,19 +18,34 @@
 #include "jni_internal.h"
 #include "nth_caller_visitor.h"
 #include "object.h"
-#include "scoped_heap_lock.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
+#include "scoped_thread_state_change.h"
 #include "thread_list.h"
 
 namespace art {
 
-static jobject GetThreadStack(JNIEnv* env, jobject javaThread) {
-  ScopedJniThreadState ts(env);
-  ScopedHeapLock heap_lock;
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, javaThread);
-  return (thread != NULL) ? GetThreadStack(ts, thread) : NULL;
+static jobject GetThreadStack(JNIEnv* env, jobject peer) {
+  bool timeout;
+  {
+    ScopedObjectAccess soa(env);
+    Thread* self = Thread::Current();
+    if (soa.Decode<Object*>(peer) == self->GetPeer()) {
+      return self->CreateInternalStackTrace(soa);
+    }
+  }
+  // Suspend thread to build stack trace.
+  Thread* thread = Thread::SuspendForDebugger(peer, true, &timeout);
+  if (thread != NULL) {
+    jobject trace;
+    {
+      ScopedObjectAccess soa(env);
+      trace = thread->CreateInternalStackTrace(soa);
+    }
+    // Restart suspended thread.
+    Runtime::Current()->GetThreadList()->Resume(thread, true);
+    return trace;
+  } else {
+    return NULL;
+  }
 }
 
 static jint VMStack_fillStackTraceElements(JNIEnv* env, jclass, jobject javaThread, jobjectArray javaSteArray) {
@@ -45,10 +60,10 @@
 
 // Returns the defining class loader of the caller's caller.
 static jobject VMStack_getCallingClassLoader(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env);
-  NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 2);
+  ScopedObjectAccess soa(env);
+  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(), 2);
   visitor.WalkStack();
-  return ts.AddLocalReference<jobject>(visitor.caller->GetDeclaringClass()->GetClassLoader());
+  return soa.AddLocalReference<jobject>(visitor.caller->GetDeclaringClass()->GetClassLoader());
 }
 
 static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap, jobject javaSystem) {
@@ -74,21 +89,21 @@
     Object* system;
     Object* class_loader;
   };
-  ScopedJniThreadState ts(env);
-  Object* bootstrap = ts.Decode<Object*>(javaBootstrap);
-  Object* system = ts.Decode<Object*>(javaSystem);
-  ClosestUserClassLoaderVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(),
+  ScopedObjectAccess soa(env);
+  Object* bootstrap = soa.Decode<Object*>(javaBootstrap);
+  Object* system = soa.Decode<Object*>(javaSystem);
+  ClosestUserClassLoaderVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(),
                                         bootstrap, system);
   visitor.WalkStack();
-  return ts.AddLocalReference<jobject>(visitor.class_loader);
+  return soa.AddLocalReference<jobject>(visitor.class_loader);
 }
 
 // Returns the class of the caller's caller's caller.
 static jclass VMStack_getStackClass2(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env);
-  NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 3);
+  ScopedObjectAccess soa(env);
+  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(), 3);
   visitor.WalkStack();
-  return ts.AddLocalReference<jclass>(visitor.caller->GetDeclaringClass());
+  return soa.AddLocalReference<jclass>(visitor.caller->GetDeclaringClass());
 }
 
 static jobjectArray VMStack_getThreadStackTrace(JNIEnv* env, jclass, jobject javaThread) {
diff --git a/src/native/java_lang_Class.cc b/src/native/java_lang_Class.cc
index bc1d0de..e63cf1a 100644
--- a/src/native/java_lang_Class.cc
+++ b/src/native/java_lang_Class.cc
@@ -20,15 +20,16 @@
 #include "nth_caller_visitor.h"
 #include "object.h"
 #include "object_utils.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
 #include "well_known_classes.h"
 
 namespace art {
 
-static Class* DecodeClass(const ScopedJniThreadState& ts, jobject java_class) {
-  Class* c = ts.Decode<Class*>(java_class);
+static Class* DecodeClass(const ScopedObjectAccess& soa, jobject java_class)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Class* c = soa.Decode<Class*>(java_class);
   DCHECK(c != NULL);
   DCHECK(c->IsClass());
   // TODO: we could EnsureInitialized here, rather than on every reflective get/set or invoke .
@@ -39,7 +40,7 @@
 
 // "name" is in "binary name" format, e.g. "dalvik.system.Debug$1".
 static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize, jobject javaLoader) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   ScopedUtfChars name(env, javaName);
   if (name.c_str() == NULL) {
     return NULL;
@@ -55,7 +56,7 @@
   }
 
   std::string descriptor(DotToDescriptor(name.c_str()));
-  ClassLoader* class_loader = ts.Decode<ClassLoader*>(javaLoader);
+  ClassLoader* class_loader = soa.Decode<ClassLoader*>(javaLoader);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Class* c = class_linker->FindClass(descriptor.c_str(), class_loader);
   if (c == NULL) {
@@ -70,12 +71,12 @@
   if (initialize) {
     class_linker->EnsureInitialized(c, true, true);
   }
-  return ts.AddLocalReference<jclass>(c);
+  return soa.AddLocalReference<jclass>(c);
 }
 
 static jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
   if (c->IsPrimitive() || c->IsArrayClass() || c->IsProxyClass()) {
     return 0;  // primitive, array and proxy classes don't have class definitions
   }
@@ -87,17 +88,22 @@
   }
 }
 
+// TODO: Remove this redundant struct when GCC annotalysis works correctly on top-level functions.
+struct WorkAroundGccAnnotalysisBug {
 template<typename T>
-static jobjectArray ToArray(const ScopedJniThreadState& ts, const char* array_class_name,
-                            const std::vector<T*>& objects) {
-  ScopedLocalRef<jclass> array_class(ts.Env(), ts.Env()->FindClass(array_class_name));
-  jobjectArray result = ts.Env()->NewObjectArray(objects.size(), array_class.get(), NULL);
+static jobjectArray ToArray(const ScopedObjectAccessUnchecked& soa, const char* array_class_name,
+                            const std::vector<T*>& objects)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  ScopedLocalRef<jclass> array_class(soa.Env(), soa.Env()->FindClass(array_class_name));
+  jobjectArray result = soa.Env()->NewObjectArray(objects.size(), array_class.get(), NULL);
   for (size_t i = 0; i < objects.size(); ++i) {
-    ScopedLocalRef<jobject> object(ts.Env(), ts.AddLocalReference<jobject>(objects[i]));
-    ts.Env()->SetObjectArrayElement(result, i, object.get());
+    ScopedLocalRef<jobject> object(soa.Env(), soa.AddLocalReference<jobject>(objects[i]));
+    soa.Env()->SetObjectArrayElement(result, i, object.get());
   }
   return result;
 }
+};
+#define ToArray(a, b, c) WorkAroundGccAnnotalysisBug::ToArray(a, b, c)
 
 static bool IsVisibleConstructor(Method* m, bool public_only) {
   if (public_only && !m->IsPublic()) {
@@ -110,8 +116,8 @@
 }
 
 static jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
   std::vector<Method*> constructors;
   for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
     Method* m = c->GetDirectMethod(i);
@@ -120,7 +126,7 @@
     }
   }
 
-  return ToArray(ts, "java/lang/reflect/Constructor", constructors);
+  return ToArray(soa, "java/lang/reflect/Constructor", constructors);
 }
 
 static bool IsVisibleField(Field* f, bool public_only) {
@@ -131,8 +137,8 @@
 }
 
 static jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
   std::vector<Field*> fields;
   FieldHelper fh;
   for (size_t i = 0; i < c->NumInstanceFields(); ++i) {
@@ -164,7 +170,7 @@
     }
   }
 
-  return ToArray(ts, "java/lang/reflect/Field", fields);
+  return ToArray(soa, "java/lang/reflect/Field", fields);
 }
 
 static bool IsVisibleMethod(Method* m, bool public_only) {
@@ -181,8 +187,8 @@
 }
 
 static jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
   if (c == NULL) {
     return NULL;
   }
@@ -218,12 +224,12 @@
     }
   }
 
-  return ToArray(ts, "java/lang/reflect/Method", methods);
+  return ToArray(soa, "java/lang/reflect/Method", methods);
 }
 
 static jobject Class_getDex(JNIEnv* env, jobject javaClass) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
 
   DexCache* dex_cache = c->GetDexCache();
   if (dex_cache == NULL) {
@@ -233,7 +239,8 @@
   return Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache).GetDexObject(env);
 }
 
-static bool MethodMatches(MethodHelper* mh, const std::string& name, ObjectArray<Class>* arg_array) {
+static bool MethodMatches(MethodHelper* mh, const std::string& name, ObjectArray<Class>* arg_array)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (name != mh->GetName()) {
     return false;
   }
@@ -254,7 +261,8 @@
 }
 
 static Method* FindConstructorOrMethodInArray(ObjectArray<Method>* methods, const std::string& name,
-                                              ObjectArray<Class>* arg_array) {
+                                              ObjectArray<Class>* arg_array)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (methods == NULL) {
     return NULL;
   }
@@ -282,10 +290,10 @@
 
 static jobject Class_getDeclaredConstructorOrMethod(JNIEnv* env, jclass javaClass, jstring javaName,
                                                     jobjectArray javaArgs) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaClass);
-  std::string name(ts.Decode<String*>(javaName)->ToModifiedUtf8());
-  ObjectArray<Class>* arg_array = ts.Decode<ObjectArray<Class>*>(javaArgs);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaClass);
+  std::string name(soa.Decode<String*>(javaName)->ToModifiedUtf8());
+  ObjectArray<Class>* arg_array = soa.Decode<ObjectArray<Class>*>(javaArgs);
 
   Method* m = FindConstructorOrMethodInArray(c->GetDirectMethods(), name, arg_array);
   if (m == NULL) {
@@ -293,16 +301,16 @@
   }
 
   if (m != NULL) {
-    return ts.AddLocalReference<jobject>(m);
+    return soa.AddLocalReference<jobject>(m);
   } else {
     return NULL;
   }
 }
 
 static jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass java_class, jobject jname) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, java_class);
-  String* name = ts.Decode<String*>(jname);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, java_class);
+  String* name = soa.Decode<String*>(jname);
   DCHECK(name->GetClass()->IsStringClass());
 
   FieldHelper fh;
@@ -314,7 +322,7 @@
         DCHECK(env->ExceptionOccurred());
         return NULL;
       }
-      return ts.AddLocalReference<jclass>(f);
+      return soa.AddLocalReference<jclass>(f);
     }
   }
   for (size_t i = 0; i < c->NumStaticFields(); ++i) {
@@ -325,40 +333,40 @@
         DCHECK(env->ExceptionOccurred());
         return NULL;
       }
-      return ts.AddLocalReference<jclass>(f);
+      return soa.AddLocalReference<jclass>(f);
     }
   }
   return NULL;
 }
 
 static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaThis);
-  return ts.AddLocalReference<jstring>(c->ComputeName());
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaThis);
+  return soa.AddLocalReference<jstring>(c->ComputeName());
 }
 
 static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(ts, javaThis));
-  return ts.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone());
+  ScopedObjectAccess soa(env);
+  SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(soa, javaThis));
+  return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone());
 }
 
 static jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
-  ScopedJniThreadState ts(env);
-  Class* lhs = DecodeClass(ts, javaLhs);
-  Class* rhs = ts.Decode<Class*>(javaRhs); // Can be null.
+  ScopedObjectAccess soa(env);
+  Class* lhs = DecodeClass(soa, javaLhs);
+  Class* rhs = soa.Decode<Class*>(javaRhs); // Can be null.
   if (rhs == NULL) {
-    ts.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "class == null");
+    soa.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "class == null");
     return JNI_FALSE;
   }
   return lhs->IsAssignableFrom(rhs) ? JNI_TRUE : JNI_FALSE;
 }
 
 static jobject Class_newInstanceImpl(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  Class* c = DecodeClass(ts, javaThis);
+  ScopedObjectAccess soa(env);
+  Class* c = DecodeClass(soa, javaThis);
   if (c->IsPrimitive() || c->IsInterface() || c->IsArrayClass() || c->IsAbstract()) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
         "Class %s can not be instantiated", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
     return NULL;
   }
@@ -369,7 +377,7 @@
 
   Method* init = c->FindDeclaredDirectMethod("<init>", "()V");
   if (init == NULL) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
         "Class %s has no default <init>()V constructor", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
     return NULL;
   }
@@ -383,20 +391,20 @@
   // constructor must be public or, if the caller is in the same package,
   // have package scope.
 
-  NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 2);
+  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(), 2);
   visitor.WalkStack();
   Class* caller_class = visitor.caller->GetDeclaringClass();
 
   ClassHelper caller_ch(caller_class);
   if (!caller_class->CanAccess(c)) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
         "Class %s is not accessible from class %s",
         PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str(),
         PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
     return NULL;
   }
   if (!caller_class->CanAccessMember(init->GetDeclaringClass(), init->GetAccessFlags())) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
         "%s is not accessible from class %s",
         PrettyMethod(init).c_str(),
         PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
@@ -405,13 +413,13 @@
 
   Object* new_obj = c->AllocObject();
   if (new_obj == NULL) {
-    DCHECK(ts.Self()->IsExceptionPending());
+    DCHECK(soa.Self()->IsExceptionPending());
     return NULL;
   }
 
   // invoke constructor; unlike reflection calls, we don't wrap exceptions
-  jclass java_class = ts.AddLocalReference<jclass>(c);
-  jmethodID mid = ts.EncodeMethod(init);
+  jclass java_class = soa.AddLocalReference<jclass>(c);
+  jmethodID mid = soa.EncodeMethod(init);
   return env->NewObject(java_class, mid);
 }
 
diff --git a/src/native/java_lang_Object.cc b/src/native/java_lang_Object.cc
index d6b1bd6..89019f7 100644
--- a/src/native/java_lang_Object.cc
+++ b/src/native/java_lang_Object.cc
@@ -16,31 +16,31 @@
 
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
 static jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  Object* o = ts.Decode<Object*>(javaThis);
-  return ts.AddLocalReference<jobject>(o->Clone());
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(javaThis);
+  return soa.AddLocalReference<jobject>(o->Clone());
 }
 
 static void Object_notify(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  Object* o = ts.Decode<Object*>(javaThis);
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(javaThis);
   o->Notify();
 }
 
 static void Object_notifyAll(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  Object* o = ts.Decode<Object*>(javaThis);
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(javaThis);
   o->NotifyAll();
 }
 
 static void Object_wait(JNIEnv* env, jobject javaThis, jlong ms, jint ns) {
-  ScopedJniThreadState ts(env);
-  Object* o = ts.Decode<Object*>(javaThis);
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(javaThis);
   o->Wait(ms, ns);
 }
 
diff --git a/src/native/java_lang_Runtime.cc b/src/native/java_lang_Runtime.cc
index 1b657b1..6dc850e 100644
--- a/src/native/java_lang_Runtime.cc
+++ b/src/native/java_lang_Runtime.cc
@@ -22,13 +22,12 @@
 #include "jni_internal.h"
 #include "object.h"
 #include "runtime.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedUtfChars.h"
 
 namespace art {
 
-static void Runtime_gc(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env);
+static void Runtime_gc(JNIEnv*, jclass) {
   Runtime::Current()->GetHeap()->CollectGarbage(false);
 }
 
@@ -45,13 +44,13 @@
  * message on failure.
  */
 static jstring Runtime_nativeLoad(JNIEnv* env, jclass, jstring javaFilename, jobject javaLoader) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   ScopedUtfChars filename(env, javaFilename);
   if (filename.c_str() == NULL) {
     return NULL;
   }
 
-  ClassLoader* classLoader = ts.Decode<ClassLoader*>(javaLoader);
+  ClassLoader* classLoader = soa.Decode<ClassLoader*>(javaLoader);
   std::string detail;
   JavaVMExt* vm = Runtime::Current()->GetJavaVM();
   bool success = vm->LoadNativeLibrary(filename.c_str(), classLoader, detail);
diff --git a/src/native/java_lang_String.cc b/src/native/java_lang_String.cc
index 96fcf96..bfdc31a 100644
--- a/src/native/java_lang_String.cc
+++ b/src/native/java_lang_String.cc
@@ -16,7 +16,7 @@
 
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 #ifdef HAVE__MEMCMP16
 // "count" is in 16-bit units.
@@ -36,9 +36,9 @@
 namespace art {
 
 static jint String_compareTo(JNIEnv* env, jobject javaThis, jobject javaRhs) {
-  ScopedJniThreadState ts(env);
-  String* lhs = ts.Decode<String*>(javaThis);
-  String* rhs = ts.Decode<String*>(javaRhs);
+  ScopedObjectAccess soa(env);
+  String* lhs = soa.Decode<String*>(javaThis);
+  String* rhs = soa.Decode<String*>(javaRhs);
 
   if (rhs == NULL) {
     Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "rhs == null");
@@ -70,11 +70,11 @@
 }
 
 static jint String_fastIndexOf(JNIEnv* env, jobject java_this, jint ch, jint start) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   // This method does not handle supplementary characters. They're dealt with in managed code.
   DCHECK_LE(ch, 0xffff);
 
-  String* s = ts.Decode<String*>(java_this);
+  String* s = soa.Decode<String*>(java_this);
 
   jint count = s->GetLength();
   if (start < 0) {
@@ -96,10 +96,10 @@
 }
 
 static jstring String_intern(JNIEnv* env, jobject javaThis) {
-  ScopedJniThreadState ts(env);
-  String* s = ts.Decode<String*>(javaThis);
+  ScopedObjectAccess soa(env);
+  String* s = soa.Decode<String*>(javaThis);
   String* result = s->Intern();
-  return ts.AddLocalReference<jstring>(result);
+  return soa.AddLocalReference<jstring>(result);
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/native/java_lang_System.cc b/src/native/java_lang_System.cc
index 76ac670..f4fe6ca 100644
--- a/src/native/java_lang_System.cc
+++ b/src/native/java_lang_System.cc
@@ -16,7 +16,7 @@
 
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 /*
  * We make guarantees about the atomicity of accesses to primitive
@@ -101,28 +101,29 @@
 
 namespace art {
 
-static void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array) {
+static void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   std::string actualType(PrettyTypeOf(array));
   Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
       "%s of type %s is not an array", identifier, actualType.c_str());
 }
 
 static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
 
   // Null pointer checks.
   if (javaSrc == NULL) {
-    ts.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "src == null");
+    soa.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "src == null");
     return;
   }
   if (javaDst == NULL) {
-    ts.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "dst == null");
+    soa.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "dst == null");
     return;
   }
 
   // Make sure source and destination are both arrays.
-  Object* srcObject = ts.Decode<Object*>(javaSrc);
-  Object* dstObject = ts.Decode<Object*>(javaDst);
+  Object* srcObject = soa.Decode<Object*>(javaSrc);
+  Object* dstObject = soa.Decode<Object*>(javaDst);
   if (!srcObject->IsArrayInstance()) {
     ThrowArrayStoreException_NotAnArray("source", srcObject);
     return;
@@ -138,7 +139,7 @@
 
   // Bounds checking.
   if (srcPos < 0 || dstPos < 0 || length < 0 || srcPos > srcArray->GetLength() - length || dstPos > dstArray->GetLength() - length) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
         "src.length=%d srcPos=%d dst.length=%d dstPos=%d length=%d",
         srcArray->GetLength(), srcPos, dstArray->GetLength(), dstPos, length);
     return;
@@ -150,7 +151,7 @@
     if (srcComponentType->IsPrimitive() != dstComponentType->IsPrimitive() || srcComponentType != dstComponentType) {
       std::string srcType(PrettyTypeOf(srcArray));
       std::string dstType(PrettyTypeOf(dstArray));
-      ts.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
+      soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
           "Incompatible types: src=%s, dst=%s", srcType.c_str(), dstType.c_str());
       return;
     }
@@ -233,7 +234,7 @@
   if (i != length) {
     std::string actualSrcType(PrettyTypeOf(o));
     std::string dstType(PrettyTypeOf(dstArray));
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
         "source[%d] of type %s cannot be stored in destination array of type %s",
         srcPos + i, actualSrcType.c_str(), dstType.c_str());
     return;
@@ -241,9 +242,9 @@
 }
 
 static jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) {
-  ScopedJniThreadState ts(env);
-  Object* o = ts.Decode<Object*>(javaObject);
-  return static_cast<jint>(reinterpret_cast<uintptr_t>(o));
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(javaObject);
+  return static_cast<jint>(o->IdentityHashCode());
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/native/java_lang_Thread.cc b/src/native/java_lang_Thread.cc
index 626255e..65042e4 100644
--- a/src/native/java_lang_Thread.cc
+++ b/src/native/java_lang_Thread.cc
@@ -17,8 +17,7 @@
 #include "debugger.h"
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedUtfChars.h"
 #include "thread.h"
 #include "thread_list.h"
@@ -26,19 +25,18 @@
 namespace art {
 
 static jobject Thread_currentThread(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env);
-  return ts.AddLocalReference<jobject>(ts.Self()->GetPeer());
+  ScopedObjectAccess soa(env);
+  return soa.AddLocalReference<jobject>(soa.Self()->GetPeer());
 }
 
 static jboolean Thread_interrupted(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env, kNative);  // Doesn't touch objects, so keep in native state.
-  return ts.Self()->Interrupted();
+  return reinterpret_cast<JNIEnvExt*>(env)->self->Interrupted() ? JNI_TRUE : JNI_FALSE;
 }
 
 static jboolean Thread_isInterrupted(JNIEnv* env, jobject java_thread) {
-  ScopedJniThreadState ts(env);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  ScopedObjectAccess soa(env);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   return (thread != NULL) ? thread->IsInterrupted() : JNI_FALSE;
 }
 
@@ -56,53 +54,62 @@
   const jint kJavaTimedWaiting = 4;
   const jint kJavaTerminated = 5;
 
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   ThreadState internal_thread_state = (has_been_started ? kTerminated : kStarting);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread != NULL) {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
     internal_thread_state = thread->GetState();
   }
   switch (internal_thread_state) {
-    case kTerminated:   return kJavaTerminated;
-    case kRunnable:     return kJavaRunnable;
-    case kTimedWaiting: return kJavaTimedWaiting;
-    case kBlocked:      return kJavaBlocked;
-    case kWaiting:      return kJavaWaiting;
-    case kStarting:     return kJavaNew;
-    case kNative:       return kJavaRunnable;
-    case kVmWait:       return kJavaWaiting;
-    case kSuspended:    return kJavaRunnable;
+    case kTerminated:                     return kJavaTerminated;
+    case kRunnable:                       return kJavaRunnable;
+    case kTimedWaiting:                   return kJavaTimedWaiting;
+    case kBlocked:                        return kJavaBlocked;
+    case kWaiting:                        return kJavaWaiting;
+    case kStarting:                       return kJavaNew;
+    case kNative:                         return kJavaRunnable;
+    case kWaitingForGcToComplete:         return kJavaWaiting;
+    case kWaitingPerformingGc:            return kJavaWaiting;
+    case kWaitingForDebuggerSend:         return kJavaWaiting;
+    case kWaitingForDebuggerToAttach:     return kJavaWaiting;
+    case kWaitingInMainDebuggerLoop:      return kJavaWaiting;
+    case kWaitingForDebuggerSuspension:   return kJavaWaiting;
+    case kWaitingForJniOnLoad:            return kJavaWaiting;
+    case kWaitingForSignalCatcherOutput:  return kJavaWaiting;
+    case kWaitingInMainSignalCatcherLoop: return kJavaWaiting;
+    case kSuspended:                      return kJavaRunnable;
     // Don't add a 'default' here so the compiler can spot incompatible enum changes.
   }
   return -1; // Unreachable.
 }
 
 static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject java_thread, jobject java_object) {
-  ScopedJniThreadState ts(env);
-  Object* object = ts.Decode<Object*>(java_object);
+  ScopedObjectAccess soa(env);
+  Object* object = soa.Decode<Object*>(java_object);
   if (object == NULL) {
     Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "object == null");
     return JNI_FALSE;
   }
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   return thread->HoldsLock(object);
 }
 
 static void Thread_nativeInterrupt(JNIEnv* env, jobject java_thread) {
-  ScopedJniThreadState ts(env);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  ScopedObjectAccess soa(env);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread != NULL) {
     thread->Interrupt();
   }
 }
 
 static void Thread_nativeSetName(JNIEnv* env, jobject java_thread, jstring java_name) {
-  ScopedJniThreadState ts(env);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  ScopedObjectAccess soa(env);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread == NULL) {
     return;
   }
@@ -119,9 +126,9 @@
  * threads at Thread.NORM_PRIORITY (5).
  */
 static void Thread_nativeSetPriority(JNIEnv* env, jobject java_thread, jint new_priority) {
-  ScopedJniThreadState ts(env);
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = Thread::FromManagedThread(ts, java_thread);
+  ScopedObjectAccess soa(env);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread != NULL) {
     thread->SetNativePriority(new_priority);
   }
diff --git a/src/native/java_lang_Throwable.cc b/src/native/java_lang_Throwable.cc
index 1c59a34..332a130 100644
--- a/src/native/java_lang_Throwable.cc
+++ b/src/native/java_lang_Throwable.cc
@@ -15,14 +15,14 @@
  */
 
 #include "jni_internal.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 
 namespace art {
 
 static jobject Throwable_nativeFillInStackTrace(JNIEnv* env, jclass) {
-  ScopedJniThreadState ts(env);
-  return ts.Self()->CreateInternalStackTrace(ts);
+  ScopedObjectAccess soa(env);
+  return soa.Self()->CreateInternalStackTrace(soa);
 }
 
 static jobjectArray Throwable_nativeGetStackTrace(JNIEnv* env, jclass, jobject javaStackState) {
diff --git a/src/native/java_lang_VMClassLoader.cc b/src/native/java_lang_VMClassLoader.cc
index 0689f74..4b5c31c 100644
--- a/src/native/java_lang_VMClassLoader.cc
+++ b/src/native/java_lang_VMClassLoader.cc
@@ -17,15 +17,15 @@
 #include "class_linker.h"
 #include "class_loader.h"
 #include "jni_internal.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedUtfChars.h"
 #include "zip_archive.h"
 
 namespace art {
 
 static jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoader, jstring javaName) {
-  ScopedJniThreadState ts(env);
-  ClassLoader* loader = ts.Decode<ClassLoader*>(javaLoader);
+  ScopedObjectAccess soa(env);
+  ClassLoader* loader = soa.Decode<ClassLoader*>(javaLoader);
   ScopedUtfChars name(env, javaName);
   if (name.c_str() == NULL) {
     return NULL;
@@ -34,7 +34,7 @@
   std::string descriptor(DotToDescriptor(name.c_str()));
   Class* c = Runtime::Current()->GetClassLinker()->LookupClass(descriptor.c_str(), loader);
   if (c != NULL && c->IsResolved()) {
-    return ts.AddLocalReference<jclass>(c);
+    return soa.AddLocalReference<jclass>(c);
   } else {
     // Class wasn't resolved so it may be erroneous or not yet ready, force the caller to go into
     // the regular loadClass code.
diff --git a/src/native/java_lang_reflect_Array.cc b/src/native/java_lang_reflect_Array.cc
index 729312e..fa59750 100644
--- a/src/native/java_lang_reflect_Array.cc
+++ b/src/native/java_lang_reflect_Array.cc
@@ -18,13 +18,14 @@
 #include "jni_internal.h"
 #include "object.h"
 #include "object_utils.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
 // Recursively create an array with multiple dimensions.  Elements may be
 // Objects or primitive types.
-static Array* CreateMultiArray(Class* array_class, int current_dimension, IntArray* dimensions) {
+static Array* CreateMultiArray(Class* array_class, int current_dimension, IntArray* dimensions)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   int32_t array_length = dimensions->Get(current_dimension++);
   SirtRef<Array> new_array(Array::Alloc(array_class, array_length));
   if (new_array.get() == NULL) {
@@ -69,12 +70,12 @@
 // subtract pieces off.  Besides, we want to start with the outermost
 // piece and work our way in.
 static jobject Array_createMultiArray(JNIEnv* env, jclass, jclass javaElementClass, jobject javaDimArray) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   DCHECK(javaElementClass != NULL);
-  Class* element_class = ts.Decode<Class*>(javaElementClass);
+  Class* element_class = soa.Decode<Class*>(javaElementClass);
   DCHECK(element_class->IsClass());
   DCHECK(javaDimArray != NULL);
-  Object* dimensions_obj = ts.Decode<Object*>(javaDimArray);
+  Object* dimensions_obj = soa.Decode<Object*>(javaDimArray);
   DCHECK(dimensions_obj->IsArrayInstance());
   DCHECK_STREQ(ClassHelper(dimensions_obj->GetClass()).GetDescriptor(), "[I");
   IntArray* dimensions_array = down_cast<IntArray*>(dimensions_obj);
@@ -90,7 +91,7 @@
   for (int i = 0; i < num_dimensions; i++) {
     int dimension = dimensions_array->Get(i);
     if (dimension < 0) {
-      ts.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;",
+      soa.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;",
           "Dimension %d: %d", i, dimension);
       return NULL;
     }
@@ -113,15 +114,15 @@
     CHECK(Thread::Current()->IsExceptionPending());
     return NULL;
   }
-  return ts.AddLocalReference<jobject>(new_array);
+  return soa.AddLocalReference<jobject>(new_array);
 }
 
 static jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementClass, jint length) {
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   DCHECK(javaElementClass != NULL);
-  Class* element_class = ts.Decode<Class*>(javaElementClass);
+  Class* element_class = soa.Decode<Class*>(javaElementClass);
   if (length < 0) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", length);
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", length);
     return NULL;
   }
   std::string descriptor;
@@ -131,16 +132,16 @@
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader());
   if (array_class == NULL) {
-    CHECK(ts.Self()->IsExceptionPending());
+    CHECK(soa.Self()->IsExceptionPending());
     return NULL;
   }
   DCHECK(array_class->IsArrayClass());
   Array* new_array = Array::Alloc(array_class, length);
   if (new_array == NULL) {
-    CHECK(ts.Self()->IsExceptionPending());
+    CHECK(soa.Self()->IsExceptionPending());
     return NULL;
   }
-  return ts.AddLocalReference<jobject>(new_array);
+  return soa.AddLocalReference<jobject>(new_array);
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/native/java_lang_reflect_Constructor.cc b/src/native/java_lang_reflect_Constructor.cc
index 564d6db..a6bd450 100644
--- a/src/native/java_lang_reflect_Constructor.cc
+++ b/src/native/java_lang_reflect_Constructor.cc
@@ -19,7 +19,7 @@
 #include "object.h"
 #include "object_utils.h"
 #include "reflection.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
@@ -31,17 +31,17 @@
  * with an interface, array, or primitive class.
  */
 static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
-  ScopedJniThreadState ts(env);
-  Method* m = ts.Decode<Object*>(javaMethod)->AsMethod();
+  ScopedObjectAccess soa(env);
+  Method* m = soa.Decode<Object*>(javaMethod)->AsMethod();
   Class* c = m->GetDeclaringClass();
   if (c->IsAbstract()) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
         "Can't instantiate abstract class %s", PrettyDescriptor(c).c_str());
     return NULL;
   }
 
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
-    DCHECK(ts.Self()->IsExceptionPending());
+    DCHECK(soa.Self()->IsExceptionPending());
     return NULL;
   }
 
@@ -50,8 +50,8 @@
     return NULL;
   }
 
-  jobject javaReceiver = ts.AddLocalReference<jobject>(receiver);
-  InvokeMethod(ts, javaMethod, javaReceiver, javaArgs);
+  jobject javaReceiver = soa.AddLocalReference<jobject>(receiver);
+  InvokeMethod(soa, javaMethod, javaReceiver, javaArgs);
 
   // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod.
   return javaReceiver;
diff --git a/src/native/java_lang_reflect_Field.cc b/src/native/java_lang_reflect_Field.cc
index b2ede63..e764b25 100644
--- a/src/native/java_lang_reflect_Field.cc
+++ b/src/native/java_lang_reflect_Field.cc
@@ -19,14 +19,16 @@
 #include "object.h"
 #include "object_utils.h"
 #include "reflection.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
-static bool GetFieldValue(const ScopedJniThreadState& ts, Object* o, Field* f, JValue& value,
-                          bool allow_references) {
+static bool GetFieldValue(const ScopedObjectAccess& soa, Object* o, Field* f,
+                          JValue& value, bool allow_references)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   DCHECK_EQ(value.GetJ(), 0LL);
-  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(), true, true)) {
+  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(),
+                                                               true, true)) {
     return false;
   }
   switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
@@ -65,18 +67,20 @@
     // Never okay.
     break;
   }
-  ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
+  soa.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
       "Not a primitive field: %s", PrettyField(f).c_str());
   return false;
 }
 
-static bool CheckReceiver(const ScopedJniThreadState& ts, jobject javaObj, Field* f, Object*& o) {
+static bool CheckReceiver(const ScopedObjectAccess& soa, jobject javaObj, Field* f,
+                          Object*& o)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (f->IsStatic()) {
     o = NULL;
     return true;
   }
 
-  o = ts.Decode<Object*>(javaObj);
+  o = soa.Decode<Object*>(javaObj);
   Class* declaringClass = f->GetDeclaringClass();
   if (!VerifyObjectInClass(o, declaringClass)) {
     return false;
@@ -85,34 +89,34 @@
 }
 
 static jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
-  ScopedJniThreadState ts(env);
-  Field* f = ts.DecodeField(env->FromReflectedField(javaField));
+  ScopedObjectAccess soa(env);
+  Field* f = soa.DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
-  if (!CheckReceiver(ts, javaObj, f, o)) {
+  if (!CheckReceiver(soa, javaObj, f, o)) {
     return NULL;
   }
 
   // Get the field's value, boxing if necessary.
   JValue value;
-  if (!GetFieldValue(ts, o, f, value, true)) {
+  if (!GetFieldValue(soa, o, f, value, true)) {
     return NULL;
   }
   BoxPrimitive(FieldHelper(f).GetTypeAsPrimitiveType(), value);
 
-  return ts.AddLocalReference<jobject>(value.GetL());
+  return soa.AddLocalReference<jobject>(value.GetL());
 }
 
 static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
-  ScopedJniThreadState ts(env);
-  Field* f = ts.DecodeField(env->FromReflectedField(javaField));
+  ScopedObjectAccess soa(env);
+  Field* f = soa.DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
-  if (!CheckReceiver(ts, javaObj, f, o)) {
+  if (!CheckReceiver(soa, javaObj, f, o)) {
     return JValue();
   }
 
   // Read the value.
   JValue field_value;
-  if (!GetFieldValue(ts, o, f, field_value, false)) {
+  if (!GetFieldValue(soa, o, f, field_value, false)) {
     return JValue();
   }
 
@@ -158,8 +162,10 @@
   return GetPrimitiveField(env, javaField, javaObj, 'S').GetS();
 }
 
-static void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references) {
-  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(), true, true)) {
+static void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(),
+                                                               true, true)) {
     return;
   }
   switch (FieldHelper(f).GetTypeAsPrimitiveType()) {
@@ -208,11 +214,11 @@
 }
 
 static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
-  ScopedJniThreadState ts(env);
-  Field* f = ts.DecodeField(env->FromReflectedField(javaField));
+  ScopedObjectAccess soa(env);
+  Field* f = soa.DecodeField(env->FromReflectedField(javaField));
 
   // Unbox the value, if necessary.
-  Object* boxed_value = ts.Decode<Object*>(javaValue);
+  Object* boxed_value = soa.Decode<Object*>(javaValue);
   JValue unboxed_value;
   if (!UnboxPrimitiveForField(boxed_value, FieldHelper(f).GetType(), unboxed_value, f)) {
     return;
@@ -220,7 +226,7 @@
 
   // Check that the receiver is non-null and an instance of the field's declaring class.
   Object* o = NULL;
-  if (!CheckReceiver(ts, javaObj, f, o)) {
+  if (!CheckReceiver(soa, javaObj, f, o)) {
     return;
   }
 
@@ -229,15 +235,15 @@
 
 static void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
                               const JValue& new_value) {
-  ScopedJniThreadState ts(env);
-  Field* f = ts.DecodeField(env->FromReflectedField(javaField));
+  ScopedObjectAccess soa(env);
+  Field* f = soa.DecodeField(env->FromReflectedField(javaField));
   Object* o = NULL;
-  if (!CheckReceiver(ts, javaObj, f, o)) {
+  if (!CheckReceiver(soa, javaObj, f, o)) {
     return;
   }
   FieldHelper fh(f);
   if (!fh.IsPrimitiveType()) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
         "Not a primitive field: %s", PrettyField(f).c_str());
     return;
   }
diff --git a/src/native/java_lang_reflect_Method.cc b/src/native/java_lang_reflect_Method.cc
index 2695822..2a6ee50 100644
--- a/src/native/java_lang_reflect_Method.cc
+++ b/src/native/java_lang_reflect_Method.cc
@@ -19,18 +19,18 @@
 #include "object.h"
 #include "object_utils.h"
 #include "reflection.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
 static jobject Method_invoke(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
-  ScopedJniThreadState ts(env);
-  return InvokeMethod(ts, javaMethod, javaReceiver, javaArgs);
+  ScopedObjectAccess soa(env);
+  return InvokeMethod(soa, javaMethod, javaReceiver, javaArgs);
 }
 
 static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
-  ScopedJniThreadState ts(env);
-  Method* proxy_method = ts.Decode<Object*>(javaMethod)->AsMethod();
+  ScopedObjectAccess soa(env);
+  Method* proxy_method = soa.Decode<Object*>(javaMethod)->AsMethod();
   CHECK(proxy_method->GetDeclaringClass()->IsProxyClass());
   SynthesizedProxyClass* proxy_class =
       down_cast<SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
@@ -44,13 +44,13 @@
   }
   CHECK_NE(throws_index, -1);
   ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
-  return ts.AddLocalReference<jobject>(declared_exceptions->Clone());
+  return soa.AddLocalReference<jobject>(declared_exceptions->Clone());
 }
 
 static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
-  ScopedJniThreadState ts(env);
-  Method* method = ts.Decode<Object*>(javaMethod)->AsMethod();
-  return ts.AddLocalReference<jobject>(method->FindOverriddenMethod());
+  ScopedObjectAccess soa(env);
+  Method* method = soa.Decode<Object*>(javaMethod)->AsMethod();
+  return soa.AddLocalReference<jobject>(method->FindOverriddenMethod());
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/native/java_lang_reflect_Proxy.cc b/src/native/java_lang_reflect_Proxy.cc
index a1337a6..81e3f169 100644
--- a/src/native/java_lang_reflect_Proxy.cc
+++ b/src/native/java_lang_reflect_Proxy.cc
@@ -18,20 +18,20 @@
 #include "class_loader.h"
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
 static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName, jobjectArray javaInterfaces, jobject javaLoader, jobjectArray javaMethods, jobjectArray javaThrows) {
-  ScopedJniThreadState ts(env);
-  String* name = ts.Decode<String*>(javaName);
-  ObjectArray<Class>* interfaces = ts.Decode<ObjectArray<Class>*>(javaInterfaces);
-  ClassLoader* loader = ts.Decode<ClassLoader*>(javaLoader);
-  ObjectArray<Method>* methods = ts.Decode<ObjectArray<Method>*>(javaMethods);
-  ObjectArray<ObjectArray<Class> >* throws = ts.Decode<ObjectArray<ObjectArray<Class> >*>(javaThrows);
+  ScopedObjectAccess soa(env);
+  String* name = soa.Decode<String*>(javaName);
+  ObjectArray<Class>* interfaces = soa.Decode<ObjectArray<Class>*>(javaInterfaces);
+  ClassLoader* loader = soa.Decode<ClassLoader*>(javaLoader);
+  ObjectArray<Method>* methods = soa.Decode<ObjectArray<Method>*>(javaMethods);
+  ObjectArray<ObjectArray<Class> >* throws = soa.Decode<ObjectArray<ObjectArray<Class> >*>(javaThrows);
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   Class* result = class_linker->CreateProxyClass(name, interfaces, loader, methods, throws);
-  return ts.AddLocalReference<jclass>(result);
+  return soa.AddLocalReference<jclass>(result);
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/src/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc b/src/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
index e3c31b0..fe95746 100644
--- a/src/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
+++ b/src/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
@@ -16,12 +16,14 @@
 
 #include "debugger.h"
 #include "logging.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedPrimitiveArray.h"
 
 namespace art {
 
 static void DdmServer_nativeSendChunk(JNIEnv* env, jclass, jint type,
                                       jbyteArray javaData, jint offset, jint length) {
+  ScopedObjectAccess soa(env);
   ScopedByteArrayRO data(env, javaData);
   DCHECK_LE(offset + length, static_cast<int32_t>(data.size()));
   Dbg::DdmSendChunk(type, length, reinterpret_cast<const uint8_t*>(&data[offset]));
diff --git a/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc b/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
index 87d2b22..b14d6ff 100644
--- a/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
+++ b/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
@@ -17,9 +17,9 @@
 #include "debugger.h"
 #include "jni_internal.h"
 #include "logging.h"
-#include "scoped_heap_lock.h"
-#include "scoped_jni_thread_state.h"
-#include "scoped_thread_list_lock.h"
+#include "../mutex.h"  // Avoid pulling in icu4c's mutex.h
+#include "scoped_thread_state_change.h"
+#include "ScopedLocalRef.h"
 #include "ScopedPrimitiveArray.h"
 #include "stack.h"
 #include "thread_list.h"
@@ -30,7 +30,8 @@
   Dbg::SetAllocTrackingEnabled(enable);
 }
 
-static jbyteArray DdmVmInternal_getRecentAllocations(JNIEnv*, jclass) {
+static jbyteArray DdmVmInternal_getRecentAllocations(JNIEnv* env, jclass) {
+  ScopedObjectAccess soa(env);
   return Dbg::GetRecentAllocations();
 }
 
@@ -38,7 +39,7 @@
   return Dbg::IsAllocTrackingEnabled();
 }
 
-static Thread* FindThreadByThinLockId(uint32_t thin_lock_id) {
+static jobject FindThreadByThinLockId(JNIEnv* env, uint32_t thin_lock_id) {
   struct ThreadFinder {
     explicit ThreadFinder(uint32_t thin_lock_id) : thin_lock_id(thin_lock_id), thread(NULL) {
     }
@@ -54,8 +55,16 @@
     Thread* thread;
   };
   ThreadFinder finder(thin_lock_id);
-  Runtime::Current()->GetThreadList()->ForEach(ThreadFinder::Callback, &finder);
-  return finder.thread;
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    Runtime::Current()->GetThreadList()->ForEach(ThreadFinder::Callback, &finder);
+  }
+  if (finder.thread != NULL) {
+    ScopedObjectAccess soa(env);
+    return soa.AddLocalReference<jobject>(finder.thread->GetPeer());
+  } else {
+    return NULL;
+  }
 }
 
 /*
@@ -63,15 +72,26 @@
  * NULL on failure, e.g. if the threadId couldn't be found.
  */
 static jobjectArray DdmVmInternal_getStackTraceById(JNIEnv* env, jclass, jint thin_lock_id) {
-  ScopedHeapLock heap_lock;
-  ScopedThreadListLock thread_list_lock;
-  Thread* thread = FindThreadByThinLockId(static_cast<uint32_t>(thin_lock_id));
-  if (thread == NULL) {
+  ScopedLocalRef<jobject> peer(env,
+                               FindThreadByThinLockId(env, static_cast<uint32_t>(thin_lock_id)));
+  if (peer.get() == NULL) {
     return NULL;
   }
-  ScopedJniThreadState ts(env);
-  jobject stack = GetThreadStack(ts, thread);
-  return (stack != NULL) ? Thread::InternalStackTraceToStackTraceElementArray(env, stack) : NULL;
+  bool timeout;
+  // Suspend thread to build stack trace.
+  Thread* thread = Thread::SuspendForDebugger(peer.get(), true, &timeout);
+  if (thread != NULL) {
+    jobject trace;
+    {
+      ScopedObjectAccess soa(env);
+      trace = thread->CreateInternalStackTrace(soa);
+    }
+    // Restart suspended thread.
+    Runtime::Current()->GetThreadList()->Resume(thread, true);
+    return Thread::InternalStackTraceToStackTraceElementArray(env, trace);
+  } else {
+    return NULL;
+  }
 }
 
 static void ThreadCountCallback(Thread*, void* context) {
@@ -109,7 +129,10 @@
 
   std::vector<uint8_t>& bytes = *reinterpret_cast<std::vector<uint8_t>*>(context);
   JDWP::Append4BE(bytes, t->GetThinLockId());
-  JDWP::Append1BE(bytes, t->GetState());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    JDWP::Append1BE(bytes, t->GetState());
+  }
   JDWP::Append4BE(bytes, t->GetTid());
   JDWP::Append4BE(bytes, utime);
   JDWP::Append4BE(bytes, stime);
@@ -119,7 +142,7 @@
 static jbyteArray DdmVmInternal_getThreadStats(JNIEnv* env, jclass) {
   std::vector<uint8_t> bytes;
   {
-    ScopedThreadListLock thread_list_lock;
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
     ThreadList* thread_list = Runtime::Current()->GetThreadList();
 
     uint16_t thread_count = 0;
@@ -139,7 +162,8 @@
   return result;
 }
 
-static jint DdmVmInternal_heapInfoNotify(JNIEnv*, jclass, jint when) {
+static jint DdmVmInternal_heapInfoNotify(JNIEnv* env, jclass, jint when) {
+  ScopedObjectAccess soa(env);
   return Dbg::DdmHandleHpifChunk(static_cast<Dbg::HpifWhen>(when));
 }
 
diff --git a/src/native/sun_misc_Unsafe.cc b/src/native/sun_misc_Unsafe.cc
index dfddd86..282731d 100644
--- a/src/native/sun_misc_Unsafe.cc
+++ b/src/native/sun_misc_Unsafe.cc
@@ -16,34 +16,34 @@
 
 #include "jni_internal.h"
 #include "object.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 namespace art {
 
 static jlong Unsafe_objectFieldOffset0(JNIEnv* env, jclass, jobject javaField) {
   // TODO: move to Java code
   jfieldID fid = env->FromReflectedField(javaField);
-  ScopedJniThreadState ts(env);
-  Field* field = ts.DecodeField(fid);
+  ScopedObjectAccess soa(env);
+  Field* field = soa.DecodeField(fid);
   return field->GetOffset().Int32Value();
 }
 
 static jint Unsafe_arrayBaseOffset0(JNIEnv* env, jclass, jclass javaArrayClass) {
   // TODO: move to Java code
-  ScopedJniThreadState ts(env);
-  Class* array_class = ts.Decode<Class*>(javaArrayClass);
+  ScopedObjectAccess soa(env);
+  Class* array_class = soa.Decode<Class*>(javaArrayClass);
   return Array::DataOffset(array_class->GetComponentSize()).Int32Value();
 }
 
 static jint Unsafe_arrayIndexScale0(JNIEnv* env, jclass, jclass javaClass) {
-  ScopedJniThreadState ts(env);
-  Class* c = ts.Decode<Class*>(javaClass);
+  ScopedObjectAccess soa(env);
+  Class* c = soa.Decode<Class*>(javaClass);
   return c->GetComponentSize();
 }
 
 static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint expectedValue, jint newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   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.
@@ -52,8 +52,8 @@
 }
 
 static jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong expectedValue, jlong newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
   // Note: android_atomic_cmpxchg() returns 0 on success, not failure.
@@ -62,10 +62,10 @@
 }
 
 static jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaExpectedValue, jobject javaNewValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
-  Object* expectedValue = ts.Decode<Object*>(javaExpectedValue);
-  Object* newValue = ts.Decode<Object*>(javaNewValue);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
+  Object* expectedValue = soa.Decode<Object*>(javaExpectedValue);
+  Object* newValue = soa.Decode<Object*>(javaNewValue);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
   // Note: android_atomic_cmpxchg() returns 0 on success, not failure.
@@ -78,105 +78,105 @@
 }
 
 static jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   return obj->GetField32(MemberOffset(offset), false);
 }
 
 static jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
   return android_atomic_acquire_load(address);
 }
 
 static void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   obj->SetField32(MemberOffset(offset), newValue, false);
 }
 
 static void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
   android_atomic_release_store(newValue, address);
 }
 
 static void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   ANDROID_MEMBAR_STORE();
   obj->SetField32(MemberOffset(offset), newValue, false);
 }
 
 static jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
   int64_t* address = reinterpret_cast<int64_t*>(raw_addr);
   return *address;
 }
 
 static jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   return obj->GetField64(MemberOffset(offset), true);
 }
 
 static void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   obj->SetField64(MemberOffset(offset), newValue, false);
 }
 
 static void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   obj->SetField64(MemberOffset(offset), newValue, true);
 }
 
 static void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   ANDROID_MEMBAR_STORE();
   obj->SetField64(MemberOffset(offset), newValue, false);
 }
 
 static jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), true);
-  return ts.AddLocalReference<jobject>(value);
+  return soa.AddLocalReference<jobject>(value);
 }
 
 static jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
   Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), false);
-  return ts.AddLocalReference<jobject>(value);
+  return soa.AddLocalReference<jobject>(value);
 }
 
 static void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
-  Object* newValue = ts.Decode<Object*>(javaNewValue);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
+  Object* newValue = soa.Decode<Object*>(javaNewValue);
   obj->SetFieldObject(MemberOffset(offset), newValue, false);
 }
 
 static void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
-  Object* newValue = ts.Decode<Object*>(javaNewValue);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
+  Object* newValue = soa.Decode<Object*>(javaNewValue);
   obj->SetFieldObject(MemberOffset(offset), newValue, true);
 }
 
 static void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
-  ScopedJniThreadState ts(env);
-  Object* obj = ts.Decode<Object*>(javaObj);
-  Object* newValue = ts.Decode<Object*>(javaNewValue);
+  ScopedObjectAccess soa(env);
+  Object* obj = soa.Decode<Object*>(javaObj);
+  Object* newValue = soa.Decode<Object*>(javaNewValue);
   ANDROID_MEMBAR_STORE();
   obj->SetFieldObject(MemberOffset(offset), newValue, false);
 }
diff --git a/src/oat/jni/arm/calling_convention_arm.cc b/src/oat/jni/arm/calling_convention_arm.cc
index 75c0380..e06a583 100644
--- a/src/oat/jni/arm/calling_convention_arm.cc
+++ b/src/oat/jni/arm/calling_convention_arm.cc
@@ -53,48 +53,27 @@
   return ReturnRegisterForShorty(GetShorty());
 }
 
-// Managed runtime calling convention
+ManagedRegister ArmJniCallingConvention::IntReturnRegister() {
+  return ArmManagedRegister::FromCoreRegister(R0);
+}
 
-std::vector<ManagedRegister> ArmManagedRuntimeCallingConvention::entry_spills_;
+// Managed runtime calling convention
 
 ManagedRegister ArmManagedRuntimeCallingConvention::MethodRegister() {
   return ArmManagedRegister::FromCoreRegister(R0);
 }
 
 bool ArmManagedRuntimeCallingConvention::IsCurrentParamInRegister() {
-  return itr_slots_ < 3;
+  return false;  // Everything moved to stack on entry.
 }
 
 bool ArmManagedRuntimeCallingConvention::IsCurrentParamOnStack() {
-  if (itr_slots_ < 2) {
-    return false;
-  } else if (itr_slots_ > 2) {
-    return true;
-  } else {
-    // handle funny case of a long/double straddling registers and the stack
-    return IsParamALongOrDouble(itr_args_);
-  }
+  return true;
 }
 
-static const Register kManagedArgumentRegisters[] = {
-  R1, R2, R3
-};
 ManagedRegister ArmManagedRuntimeCallingConvention::CurrentParamRegister() {
-  CHECK(IsCurrentParamInRegister());
-  if (IsParamALongOrDouble(itr_args_)) {
-    if (itr_slots_ == 0) {
-      return ArmManagedRegister::FromRegisterPair(R1_R2);
-    } else if (itr_slots_ == 1) {
-      return ArmManagedRegister::FromRegisterPair(R2_R3);
-    } else {
-      // This is a long/double split between registers and the stack
-      return ArmManagedRegister::FromCoreRegister(
-        kManagedArgumentRegisters[itr_slots_]);
-    }
-  } else {
-    return
-      ArmManagedRegister::FromCoreRegister(kManagedArgumentRegisters[itr_slots_]);
-  }
+  LOG(FATAL) << "Should not reach here";
+  return ManagedRegister::NoRegister();
 }
 
 FrameOffset ArmManagedRuntimeCallingConvention::CurrentParamStackOffset() {
@@ -103,15 +82,26 @@
       FrameOffset(displacement_.Int32Value() +   // displacement
                   kPointerSize +                 // Method*
                   (itr_slots_ * kPointerSize));  // offset into in args
-  if (itr_slots_ == 2) {
-    // the odd spanning case, bump the offset to skip the first half of the
-    // input which is in a register
-    CHECK(IsCurrentParamInRegister());
-    result = FrameOffset(result.Int32Value() + 4);
-  }
   return result;
 }
 
+const std::vector<ManagedRegister>& ArmManagedRuntimeCallingConvention::EntrySpills() {
+  // We spill the argument registers on ARM to free them up for scratch use, we then assume
+  // all arguments are on the stack.
+  if (entry_spills_.size() == 0) {
+    size_t num_spills = NumArgs() + NumLongOrDoubleArgs();
+    if (num_spills > 0) {
+      entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R1));
+      if (num_spills > 1) {
+        entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R2));
+        if (num_spills > 2) {
+          entry_spills_.push_back(ArmManagedRegister::FromCoreRegister(R3));
+        }
+      }
+    }
+  }
+  return entry_spills_;
+}
 // JNI calling convention
 
 ArmJniCallingConvention::ArmJniCallingConvention(bool is_static, bool is_synchronized,
@@ -165,11 +155,6 @@
                  kStackAlignment);
 }
 
-// Will reg be crushed by an outgoing argument?
-bool ArmJniCallingConvention::IsMethodRegisterClobberedPreCall() {
-  return true;  // The method register R0 is always clobbered by the JNIEnv
-}
-
 // JniCallingConvention ABI follows AAPCS where longs and doubles must occur
 // in even register numbers and stack slots
 void ArmJniCallingConvention::Next() {
diff --git a/src/oat/jni/arm/calling_convention_arm.h b/src/oat/jni/arm/calling_convention_arm.h
index 527ffa1..b536b6b 100644
--- a/src/oat/jni/arm/calling_convention_arm.h
+++ b/src/oat/jni/arm/calling_convention_arm.h
@@ -36,12 +36,10 @@
   virtual bool IsCurrentParamOnStack();
   virtual ManagedRegister CurrentParamRegister();
   virtual FrameOffset CurrentParamStackOffset();
-  virtual const std::vector<ManagedRegister>& EntrySpills() {
-    DCHECK(entry_spills_.empty());
-    return entry_spills_;
-  }
+  virtual const std::vector<ManagedRegister>& EntrySpills();
+
  private:
-  static std::vector<ManagedRegister> entry_spills_;
+  std::vector<ManagedRegister> entry_spills_;
 
   DISALLOW_COPY_AND_ASSIGN(ArmManagedRuntimeCallingConvention);
 };
@@ -52,6 +50,7 @@
   virtual ~ArmJniCallingConvention() {}
   // Calling convention
   virtual ManagedRegister ReturnRegister();
+  virtual ManagedRegister IntReturnRegister();
   virtual ManagedRegister InterproceduralScratchRegister();
   // JNI calling convention
   virtual void Next();  // Override default behavior for AAPCS
@@ -65,7 +64,6 @@
   virtual uint32_t FpSpillMask() const {
     return 0;  // Floats aren't spilled in JNI down call
   }
-  virtual bool IsMethodRegisterClobberedPreCall();
   virtual bool IsCurrentParamInRegister();
   virtual bool IsCurrentParamOnStack();
   virtual ManagedRegister CurrentParamRegister();
diff --git a/src/oat/jni/calling_convention.h b/src/oat/jni/calling_convention.h
index ae6c7ed..121d1f8 100644
--- a/src/oat/jni/calling_convention.h
+++ b/src/oat/jni/calling_convention.h
@@ -41,9 +41,9 @@
     return result;
   }
 
-  // Register that holds result of this method
+  // Register that holds result of this method invocation.
   virtual ManagedRegister ReturnRegister() = 0;
-  // Register reserved for scratch usage during procedure calls
+  // Register reserved for scratch usage during procedure calls.
   virtual ManagedRegister InterproceduralScratchRegister() = 0;
 
   // Offset of Method within the frame
@@ -224,6 +224,8 @@
   // Location where the return value of a call can be squirreled if another
   // call is made following the native call
   FrameOffset ReturnValueSaveLocation() const;
+  // Register that holds result if it is integer.
+  virtual ManagedRegister IntReturnRegister() = 0;
 
   // Callee save registers to spill prior to native code (which may clobber)
   virtual const std::vector<ManagedRegister>& CalleeSaveRegisters() const = 0;
@@ -232,10 +234,6 @@
   virtual uint32_t CoreSpillMask() const = 0;
   virtual uint32_t FpSpillMask() const = 0;
 
-  // Returns true if the method register will have been clobbered during argument
-  // set up
-  virtual bool IsMethodRegisterClobberedPreCall() = 0;
-
   // An extra scratch register live after the call
   virtual ManagedRegister ReturnScratchRegister() const = 0;
 
diff --git a/src/oat/jni/jni_compiler.cc b/src/oat/jni/jni_compiler.cc
index 4916072..a9a1bca 100644
--- a/src/oat/jni/jni_compiler.cc
+++ b/src/oat/jni/jni_compiler.cc
@@ -36,31 +36,336 @@
 
 namespace art {
 
-static void ChangeThreadState(Assembler* jni_asm, ThreadState new_state,
-                              ManagedRegister scratch, ManagedRegister return_reg,
-                              FrameOffset return_save_location,
-                              size_t return_size) {
-  /*
-   * This code mirrors that of Thread::SetState where detail is given on why
-   * barriers occur when they do.
-   */
-  if (new_state == kRunnable) {
-    /*
-     * Change our status to kRunnable.  The transition requires
-     * that we check for pending suspension, because the runtime considers
-     * us to be "asleep" in all other states, and another thread could
-     * be performing a GC now.
-     */
-    __ StoreImmediateToThread(Thread::StateOffset(), kRunnable, scratch);
-    __ MemoryBarrier(scratch);
-    __ SuspendPoll(scratch, return_reg, return_save_location, return_size);
-  } else {
-    /*
-     * Not changing to kRunnable. No additional work required.
-     */
-    __ MemoryBarrier(scratch);
-    __ StoreImmediateToThread(Thread::StateOffset(), new_state, scratch);
+static void CopyParameter(Assembler* jni_asm,
+                          ManagedRuntimeCallingConvention* mr_conv,
+                          JniCallingConvention* jni_conv,
+                          size_t frame_size, size_t out_arg_size);
+static void SetNativeParameter(Assembler* jni_asm,
+                               JniCallingConvention* jni_conv,
+                               ManagedRegister in_reg);
+
+// Generate the JNI bridge for the given method, general contract:
+// - Arguments are in the managed runtime format, either on stack or in
+//   registers, a reference to the method object is supplied as part of this
+//   convention.
+//
+CompiledMethod* ArtJniCompileMethodInternal(Compiler& compiler,
+                                            uint32_t access_flags, uint32_t method_idx,
+                                            const DexFile& dex_file) {
+  const bool is_native = (access_flags & kAccNative) != 0;
+  CHECK(is_native);
+  const bool is_static = (access_flags & kAccStatic) != 0;
+  const bool is_synchronized = (access_flags & kAccSynchronized) != 0;
+  const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
+  InstructionSet instruction_set = compiler.GetInstructionSet();
+  if (instruction_set == kThumb2) {
+    instruction_set = kArm;
   }
+  // Calling conventions used to iterate over parameters to method
+  UniquePtr<JniCallingConvention> jni_conv(
+      JniCallingConvention::Create(is_static, is_synchronized, shorty, instruction_set));
+  UniquePtr<ManagedRuntimeCallingConvention> mr_conv(
+      ManagedRuntimeCallingConvention::Create(is_static, is_synchronized, shorty, instruction_set));
+
+  // Assembler that holds generated instructions
+  UniquePtr<Assembler> jni_asm(Assembler::Create(instruction_set));
+  bool should_disassemble = false;
+
+  // Offsets into data structures
+  // TODO: if cross compiling these offsets are for the host not the target
+  const Offset functions(OFFSETOF_MEMBER(JNIEnvExt, functions));
+  const Offset monitor_enter(OFFSETOF_MEMBER(JNINativeInterface, MonitorEnter));
+  const Offset monitor_exit(OFFSETOF_MEMBER(JNINativeInterface, MonitorExit));
+
+  // 1. Build the frame saving all callee saves
+  const size_t frame_size(jni_conv->FrameSize());
+  const std::vector<ManagedRegister>& callee_save_regs = jni_conv->CalleeSaveRegisters();
+  __ BuildFrame(frame_size, mr_conv->MethodRegister(), callee_save_regs, mr_conv->EntrySpills());
+
+  // 2. Set up the StackIndirectReferenceTable
+  mr_conv->ResetIterator(FrameOffset(frame_size));
+  jni_conv->ResetIterator(FrameOffset(0));
+  __ StoreImmediateToFrame(jni_conv->SirtNumRefsOffset(),
+                           jni_conv->ReferenceCount(),
+                           mr_conv->InterproceduralScratchRegister());
+  __ CopyRawPtrFromThread(jni_conv->SirtLinkOffset(),
+                          Thread::TopSirtOffset(),
+                          mr_conv->InterproceduralScratchRegister());
+  __ StoreStackOffsetToThread(Thread::TopSirtOffset(),
+                              jni_conv->SirtOffset(),
+                              mr_conv->InterproceduralScratchRegister());
+
+  // 3. Place incoming reference arguments into SIRT
+  jni_conv->Next();  // Skip JNIEnv*
+  // 3.5. Create Class argument for static methods out of passed method
+  if (is_static) {
+    FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
+    // Check sirt offset is within frame
+    CHECK_LT(sirt_offset.Uint32Value(), frame_size);
+    __ LoadRef(jni_conv->InterproceduralScratchRegister(),
+               mr_conv->MethodRegister(), Method::DeclaringClassOffset());
+    __ VerifyObject(jni_conv->InterproceduralScratchRegister(), false);
+    __ StoreRef(sirt_offset, jni_conv->InterproceduralScratchRegister());
+    jni_conv->Next();  // in SIRT so move to next argument
+  }
+  while (mr_conv->HasNext()) {
+    CHECK(jni_conv->HasNext());
+    bool ref_param = jni_conv->IsCurrentParamAReference();
+    CHECK(!ref_param || mr_conv->IsCurrentParamAReference());
+    // References need placing in SIRT and the entry value passing
+    if (ref_param) {
+      // Compute SIRT entry, note null is placed in the SIRT but its boxed value
+      // must be NULL
+      FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
+      // Check SIRT offset is within frame and doesn't run into the saved segment state
+      CHECK_LT(sirt_offset.Uint32Value(), frame_size);
+      CHECK_NE(sirt_offset.Uint32Value(),
+               jni_conv->SavedLocalReferenceCookieOffset().Uint32Value());
+      bool input_in_reg = mr_conv->IsCurrentParamInRegister();
+      bool input_on_stack = mr_conv->IsCurrentParamOnStack();
+      CHECK(input_in_reg || input_on_stack);
+
+      if (input_in_reg) {
+        ManagedRegister in_reg  =  mr_conv->CurrentParamRegister();
+        __ VerifyObject(in_reg, mr_conv->IsCurrentArgPossiblyNull());
+        __ StoreRef(sirt_offset, in_reg);
+      } else if (input_on_stack) {
+        FrameOffset in_off  = mr_conv->CurrentParamStackOffset();
+        __ VerifyObject(in_off, mr_conv->IsCurrentArgPossiblyNull());
+        __ CopyRef(sirt_offset, in_off,
+                   mr_conv->InterproceduralScratchRegister());
+      }
+    }
+    mr_conv->Next();
+    jni_conv->Next();
+  }
+
+  // 4. Write out the end of the quick frames.
+  __ StoreStackPointerToThread(Thread::TopOfManagedStackOffset());
+  __ StoreImmediateToThread(Thread::TopOfManagedStackPcOffset(), 0,
+                            mr_conv->InterproceduralScratchRegister());
+
+  // 5. Move frame down to allow space for out going args.
+  const size_t out_arg_size = jni_conv->OutArgSize();
+  __ IncreaseFrameSize(out_arg_size);
+
+
+  // 6. Call into appropriate JniMethodStart passing Thread* so that transition out of Runnable
+  //    can occur. The result is the saved JNI local state that is restored by the exit call. We
+  //    abuse the JNI calling convention here, that is guaranteed to support passing 2 pointer
+  //    arguments.
+  uintptr_t jni_start = is_synchronized ? ENTRYPOINT_OFFSET(pJniMethodStartSynchronized)
+                                        : ENTRYPOINT_OFFSET(pJniMethodStart);
+  jni_conv->ResetIterator(FrameOffset(out_arg_size));
+  FrameOffset locked_object_sirt_offset(0);
+  if (is_synchronized) {
+    // Pass object for locking.
+    jni_conv->Next();  // Skip JNIEnv.
+    locked_object_sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
+    jni_conv->ResetIterator(FrameOffset(out_arg_size));
+    if (jni_conv->IsCurrentParamOnStack()) {
+      FrameOffset out_off = jni_conv->CurrentParamStackOffset();
+      __ CreateSirtEntry(out_off, locked_object_sirt_offset,
+                         mr_conv->InterproceduralScratchRegister(),
+                         false);
+    } else {
+      ManagedRegister out_reg = jni_conv->CurrentParamRegister();
+      __ CreateSirtEntry(out_reg, locked_object_sirt_offset,
+                         ManagedRegister::NoRegister(), false);
+    }
+    jni_conv->Next();
+  }
+  if (jni_conv->IsCurrentParamInRegister()) {
+    __ GetCurrentThread(jni_conv->CurrentParamRegister());
+    __ Call(jni_conv->CurrentParamRegister(), Offset(jni_start),
+            jni_conv->InterproceduralScratchRegister());
+  } else {
+    __ GetCurrentThread(jni_conv->CurrentParamStackOffset(),
+                        jni_conv->InterproceduralScratchRegister());
+    __ Call(ThreadOffset(jni_start), jni_conv->InterproceduralScratchRegister());
+  }
+  if (is_synchronized) {  // Check for exceptions from monitor enter.
+    __ ExceptionPoll(jni_conv->InterproceduralScratchRegister(), out_arg_size);
+  }
+  FrameOffset saved_cookie_offset = jni_conv->SavedLocalReferenceCookieOffset();
+  __ Store(saved_cookie_offset, jni_conv->IntReturnRegister(), 4);
+
+  // 7. Iterate over arguments placing values from managed calling convention in
+  //    to the convention required for a native call (shuffling). For references
+  //    place an index/pointer to the reference after checking whether it is
+  //    NULL (which must be encoded as NULL).
+  //    Note: we do this prior to materializing the JNIEnv* and static's jclass to
+  //    give as many free registers for the shuffle as possible
+  mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size));
+  uint32_t args_count = 0;
+  while (mr_conv->HasNext()) {
+    args_count++;
+    mr_conv->Next();
+  }
+
+  // Do a backward pass over arguments, so that the generated code will be "mov
+  // R2, R3; mov R1, R2" instead of "mov R1, R2; mov R2, R3."
+  // TODO: A reverse iterator to improve readability.
+  for (uint32_t i = 0; i < args_count; ++i) {
+    mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size));
+    jni_conv->ResetIterator(FrameOffset(out_arg_size));
+    jni_conv->Next();  // Skip JNIEnv*.
+    if (is_static) {
+      jni_conv->Next();  // Skip Class for now.
+    }
+    // Skip to the argument we're interested in.
+    for (uint32_t j = 0; j < args_count - i - 1; ++j) {
+      mr_conv->Next();
+      jni_conv->Next();
+    }
+    CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size, out_arg_size);
+  }
+  if (is_static) {
+    // Create argument for Class
+    mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size));
+    jni_conv->ResetIterator(FrameOffset(out_arg_size));
+    jni_conv->Next();  // Skip JNIEnv*
+    FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
+    if (jni_conv->IsCurrentParamOnStack()) {
+      FrameOffset out_off = jni_conv->CurrentParamStackOffset();
+      __ CreateSirtEntry(out_off, sirt_offset,
+                         mr_conv->InterproceduralScratchRegister(),
+                         false);
+    } else {
+      ManagedRegister out_reg = jni_conv->CurrentParamRegister();
+      __ CreateSirtEntry(out_reg, sirt_offset,
+                         ManagedRegister::NoRegister(), false);
+    }
+  }
+
+  // 8. Create 1st argument, the JNI environment ptr.
+  jni_conv->ResetIterator(FrameOffset(out_arg_size));
+  // Register that will hold local indirect reference table
+  if (jni_conv->IsCurrentParamInRegister()) {
+    ManagedRegister jni_env = jni_conv->CurrentParamRegister();
+    DCHECK(!jni_env.Equals(jni_conv->InterproceduralScratchRegister()));
+    __ LoadRawPtrFromThread(jni_env, Thread::JniEnvOffset());
+  } else {
+    FrameOffset jni_env = jni_conv->CurrentParamStackOffset();
+    __ CopyRawPtrFromThread(jni_env, Thread::JniEnvOffset(),
+                            jni_conv->InterproceduralScratchRegister());
+  }
+
+  // 9. Plant call to native code associated with method.
+  __ Call(jni_conv->MethodStackOffset(), Method::NativeMethodOffset(),
+          mr_conv->InterproceduralScratchRegister());
+
+  // 10. Fix differences in result widths.
+  if (instruction_set == kX86) {
+    if (jni_conv->GetReturnType() == Primitive::kPrimByte ||
+        jni_conv->GetReturnType() == Primitive::kPrimShort) {
+      __ SignExtend(jni_conv->ReturnRegister(),
+                    Primitive::ComponentSize(jni_conv->GetReturnType()));
+    } else if (jni_conv->GetReturnType() == Primitive::kPrimBoolean ||
+               jni_conv->GetReturnType() == Primitive::kPrimChar) {
+      __ ZeroExtend(jni_conv->ReturnRegister(),
+                    Primitive::ComponentSize(jni_conv->GetReturnType()));
+    }
+  }
+
+  // 11. Save return value
+  bool reference_return = jni_conv->IsReturnAReference();
+  FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation();
+  if (jni_conv->SizeOfReturnValue() != 0 && !reference_return) {
+    CHECK_LT(return_save_location.Uint32Value(), frame_size+out_arg_size);
+    __ Store(return_save_location, jni_conv->ReturnRegister(), jni_conv->SizeOfReturnValue());
+  }
+
+  // 12. Call into JNI method end possibly passing a returned reference, the method and the current
+  //     thread.
+  {
+    // Modify iterator for call, important offsets were saved above.
+    size_t jni_end_arg_count = 0;
+    if (reference_return) { jni_end_arg_count++; }
+    if (is_synchronized) { jni_end_arg_count++; }
+    const char* jni_end_shorty = jni_end_arg_count == 0 ? "I"
+                                                        : (jni_end_arg_count == 1 ? "II" : "III");
+    jni_conv.reset(JniCallingConvention::Create(is_static, is_synchronized, jni_end_shorty,
+                                                instruction_set));
+    // Ensure out arguments will fit in space taken before (we expect this due to stack alignment).
+    size_t jni_end_out_arg_size = jni_conv->OutArgSize();
+    CHECK_LE(jni_end_out_arg_size, out_arg_size);
+    jni_conv->ResetIterator(FrameOffset(jni_end_out_arg_size));
+  }
+  uintptr_t jni_end;
+  if (reference_return) {
+    // Pass result.
+    jni_end = is_synchronized ? ENTRYPOINT_OFFSET(pJniMethodEndWithReferenceSynchronized)
+                              : ENTRYPOINT_OFFSET(pJniMethodEndWithReference);
+    SetNativeParameter(jni_asm.get(), jni_conv.get(), jni_conv->ReturnRegister());
+    jni_conv->Next();
+  } else {
+    jni_end = is_synchronized ? ENTRYPOINT_OFFSET(pJniMethodEndSynchronized)
+                              : ENTRYPOINT_OFFSET(pJniMethodEnd);
+  }
+  // Pass saved local reference state.
+  if (jni_conv->IsCurrentParamOnStack()) {
+    FrameOffset out_off = jni_conv->CurrentParamStackOffset();
+    __ Copy(out_off, saved_cookie_offset, jni_conv->InterproceduralScratchRegister(), 4);
+  } else {
+    ManagedRegister out_reg = jni_conv->CurrentParamRegister();
+    __ Load(out_reg, saved_cookie_offset, 4);
+  }
+  jni_conv->Next();
+  if (is_synchronized) {
+    // Pass object for unlocking.
+    if (jni_conv->IsCurrentParamOnStack()) {
+      FrameOffset out_off = jni_conv->CurrentParamStackOffset();
+      __ CreateSirtEntry(out_off, locked_object_sirt_offset,
+                         jni_conv->InterproceduralScratchRegister(),
+                         false);
+    } else {
+      ManagedRegister out_reg = jni_conv->CurrentParamRegister();
+      __ CreateSirtEntry(out_reg, locked_object_sirt_offset,
+                         ManagedRegister::NoRegister(), false);
+    }
+    jni_conv->Next();
+  }
+  if (jni_conv->IsCurrentParamInRegister()) {
+    __ GetCurrentThread(jni_conv->CurrentParamRegister());
+    __ Call(jni_conv->CurrentParamRegister(), Offset(jni_end),
+            jni_conv->InterproceduralScratchRegister());
+  } else {
+    __ GetCurrentThread(jni_conv->CurrentParamStackOffset(),
+                        jni_conv->InterproceduralScratchRegister());
+    __ Call(ThreadOffset(jni_end), jni_conv->InterproceduralScratchRegister());
+  }
+
+  // 13. Reload return value
+  if (jni_conv->SizeOfReturnValue() != 0 && !reference_return) {
+    __ Load(mr_conv->ReturnRegister(), return_save_location, mr_conv->SizeOfReturnValue());
+  }
+
+  // 14. Move frame up now we're done with the out arg space.
+  __ DecreaseFrameSize(out_arg_size);
+
+  // 15. Process pending exceptions from JNI call or monitor exit.
+  __ ExceptionPoll(jni_conv->InterproceduralScratchRegister(), 0);
+
+  // 16. Remove activation - no need to restore callee save registers because we didn't clobber
+  //     them.
+  __ RemoveFrame(frame_size, std::vector<ManagedRegister>());
+
+  // 17. Finalize code generation
+  __ EmitSlowPaths();
+  size_t cs = __ CodeSize();
+  std::vector<uint8_t> managed_code(cs);
+  MemoryRegion code(&managed_code[0], managed_code.size());
+  __ FinalizeInstructions(code);
+  if (should_disassemble) {
+    UniquePtr<Disassembler> disassembler(Disassembler::Create(instruction_set));
+    disassembler->Dump(LOG(INFO), &managed_code[0], &managed_code[managed_code.size()]);
+  }
+  return new CompiledMethod(instruction_set,
+                            managed_code,
+                            frame_size,
+                            jni_conv->CoreSpillMask(),
+                            jni_conv->FpSpillMask());
 }
 
 // Copy a single parameter from the managed to the JNI calling convention
@@ -166,441 +471,6 @@
   }
 }
 
-static bool IsRegisterPair(InstructionSet instruction_set, ManagedRegister r) {
-  return ((instruction_set == kArm && r.AsArm().IsRegisterPair()) ||
-          (instruction_set == kX86 && r.AsX86().IsRegisterPair()));
-}
-
-// Generate the JNI bridge for the given method, general contract:
-// - Arguments are in the managed runtime format, either on stack or in
-//   registers, a reference to the method object is supplied as part of this
-//   convention.
-//
-CompiledMethod* ArtJniCompileMethodInternal(Compiler& compiler,
-                                            uint32_t access_flags, uint32_t method_idx,
-                                            const DexFile& dex_file) {
-  const bool is_native = (access_flags & kAccNative) != 0;
-  CHECK(is_native);
-  const bool is_static = (access_flags & kAccStatic) != 0;
-  const bool is_synchronized = (access_flags & kAccSynchronized) != 0;
-  const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx));
-  InstructionSet instruction_set = compiler.GetInstructionSet();
-  if (instruction_set == kThumb2) {
-    instruction_set = kArm;
-  }
-  // Calling conventions used to iterate over parameters to method
-  UniquePtr<JniCallingConvention> jni_conv(
-      JniCallingConvention::Create(is_static, is_synchronized, shorty, instruction_set));
-  UniquePtr<ManagedRuntimeCallingConvention> mr_conv(
-      ManagedRuntimeCallingConvention::Create(is_static, is_synchronized, shorty, instruction_set));
-
-  // Assembler that holds generated instructions
-  UniquePtr<Assembler> jni_asm(Assembler::Create(instruction_set));
-  bool should_disassemble = false;
-
-  // Offsets into data structures
-  // TODO: if cross compiling these offsets are for the host not the target
-  const Offset functions(OFFSETOF_MEMBER(JNIEnvExt, functions));
-  const Offset monitor_enter(OFFSETOF_MEMBER(JNINativeInterface, MonitorEnter));
-  const Offset monitor_exit(OFFSETOF_MEMBER(JNINativeInterface, MonitorExit));
-
-  // 1. Build the frame saving all callee saves
-  const size_t frame_size(jni_conv->FrameSize());
-  const std::vector<ManagedRegister>& callee_save_regs = jni_conv->CalleeSaveRegisters();
-  __ BuildFrame(frame_size, mr_conv->MethodRegister(), callee_save_regs, mr_conv->EntrySpills());
-
-  // 2. Set up the StackIndirectReferenceTable
-  mr_conv->ResetIterator(FrameOffset(frame_size));
-  jni_conv->ResetIterator(FrameOffset(0));
-  __ StoreImmediateToFrame(jni_conv->SirtNumRefsOffset(),
-                           jni_conv->ReferenceCount(),
-                           mr_conv->InterproceduralScratchRegister());
-  __ CopyRawPtrFromThread(jni_conv->SirtLinkOffset(),
-                          Thread::TopSirtOffset(),
-                          mr_conv->InterproceduralScratchRegister());
-  __ StoreStackOffsetToThread(Thread::TopSirtOffset(),
-                              jni_conv->SirtOffset(),
-                              mr_conv->InterproceduralScratchRegister());
-
-  // 3. Place incoming reference arguments into SIRT
-  jni_conv->Next();  // Skip JNIEnv*
-  // 3.5. Create Class argument for static methods out of passed method
-  if (is_static) {
-    FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
-    // Check sirt offset is within frame
-    CHECK_LT(sirt_offset.Uint32Value(), frame_size);
-    __ LoadRef(jni_conv->InterproceduralScratchRegister(),
-               mr_conv->MethodRegister(), Method::DeclaringClassOffset());
-    __ VerifyObject(jni_conv->InterproceduralScratchRegister(), false);
-    __ StoreRef(sirt_offset, jni_conv->InterproceduralScratchRegister());
-    jni_conv->Next();  // in SIRT so move to next argument
-  }
-  while (mr_conv->HasNext()) {
-    CHECK(jni_conv->HasNext());
-    bool ref_param = jni_conv->IsCurrentParamAReference();
-    CHECK(!ref_param || mr_conv->IsCurrentParamAReference());
-    // References need placing in SIRT and the entry value passing
-    if (ref_param) {
-      // Compute SIRT entry, note null is placed in the SIRT but its boxed value
-      // must be NULL
-      FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
-      // Check SIRT offset is within frame and doesn't run into the saved segment state
-      CHECK_LT(sirt_offset.Uint32Value(), frame_size);
-      CHECK_NE(sirt_offset.Uint32Value(),
-               jni_conv->SavedLocalReferenceCookieOffset().Uint32Value());
-      bool input_in_reg = mr_conv->IsCurrentParamInRegister();
-      bool input_on_stack = mr_conv->IsCurrentParamOnStack();
-      CHECK(input_in_reg || input_on_stack);
-
-      if (input_in_reg) {
-        ManagedRegister in_reg  =  mr_conv->CurrentParamRegister();
-        __ VerifyObject(in_reg, mr_conv->IsCurrentArgPossiblyNull());
-        __ StoreRef(sirt_offset, in_reg);
-      } else if (input_on_stack) {
-        FrameOffset in_off  = mr_conv->CurrentParamStackOffset();
-        __ VerifyObject(in_off, mr_conv->IsCurrentArgPossiblyNull());
-        __ CopyRef(sirt_offset, in_off,
-                   mr_conv->InterproceduralScratchRegister());
-      }
-    }
-    mr_conv->Next();
-    jni_conv->Next();
-  }
-
-  // 4. Transition from being in managed to native code. Save the top_of_managed_stack_
-  // so that the managed stack can be crawled while in native code. Clear the corresponding
-  // PC value that has no meaning for the this frame.
-  __ StoreStackPointerToThread(Thread::TopOfManagedStackOffset());
-  __ StoreImmediateToThread(Thread::TopOfManagedStackPcOffset(), 0,
-                            mr_conv->InterproceduralScratchRegister());
-  ChangeThreadState(jni_asm.get(), kNative,
-                    mr_conv->InterproceduralScratchRegister(),
-                    ManagedRegister::NoRegister(), FrameOffset(0), 0);
-
-  // 5. Move frame down to allow space for out going args. Do for as short a
-  //    time as possible to aid profiling..
-  const size_t out_arg_size = jni_conv->OutArgSize();
-  __ IncreaseFrameSize(out_arg_size);
-
-  // 6. Acquire lock for synchronized methods.
-  if (is_synchronized) {
-    // Compute arguments in registers to preserve
-    mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size));
-    std::vector<ManagedRegister> live_argument_regs;
-    std::vector<size_t> live_argument_regs_size;
-    while (mr_conv->HasNext()) {
-      if (mr_conv->IsCurrentParamInRegister()) {
-        live_argument_regs.push_back(mr_conv->CurrentParamRegister());
-        live_argument_regs_size.push_back(mr_conv->CurrentParamSize());
-      }
-      mr_conv->Next();
-    }
-
-    // Copy arguments to preserve to callee save registers
-    CHECK_LE(live_argument_regs.size(), callee_save_regs.size());
-    for (size_t in = 0, out = 0; in < live_argument_regs.size(); ++in) {
-      size_t size = live_argument_regs_size.at(in);
-      if (IsRegisterPair(instruction_set, live_argument_regs.at(in))) {
-        CHECK_EQ(instruction_set, kArm);
-        arm::ArmManagedRegister pair(live_argument_regs.at(in).AsArm());
-        arm::Register lo(pair.AsRegisterPairLow());
-        arm::Register hi(pair.AsRegisterPairHigh());
-        __ Move(callee_save_regs.at(out++), arm::ArmManagedRegister::FromCoreRegister(lo), size / 2);
-        __ Move(callee_save_regs.at(out++), arm::ArmManagedRegister::FromCoreRegister(hi), size / 2);
-      } else {
-        __ Move(callee_save_regs.at(out++), live_argument_regs.at(in), size);
-      }
-    }
-
-    // Get SIRT entry for 1st argument (jclass or this) to be 1st argument to
-    // monitor enter
-    mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size));
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    jni_conv->Next();  // Skip JNIEnv*
-    if (is_static) {
-      FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
-      if (jni_conv->IsCurrentParamOnStack()) {
-        FrameOffset out_off = jni_conv->CurrentParamStackOffset();
-        __ CreateSirtEntry(out_off, sirt_offset,
-                           mr_conv->InterproceduralScratchRegister(),
-                           false);
-      } else {
-        ManagedRegister out_reg = jni_conv->CurrentParamRegister();
-        __ CreateSirtEntry(out_reg, sirt_offset,
-                           ManagedRegister::NoRegister(), false);
-      }
-    } else {
-      CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size,
-                    out_arg_size);
-    }
-
-    // Generate JNIEnv* in place and leave a copy in jni_fns_register
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    ManagedRegister jni_fns_register =
-        jni_conv->InterproceduralScratchRegister();
-    __ LoadRawPtrFromThread(jni_fns_register, Thread::JniEnvOffset());
-    SetNativeParameter(jni_asm.get(), jni_conv.get(), jni_fns_register);
-
-    // Call JNIEnv->MonitorEnter(object)
-    __ LoadRawPtr(jni_fns_register, jni_fns_register, functions);
-    __ Call(jni_fns_register, monitor_enter,
-                  jni_conv->InterproceduralScratchRegister());
-
-    // Check for exceptions
-    __ ExceptionPoll(jni_conv->InterproceduralScratchRegister());
-
-    // Restore live arguments
-    for (size_t in = 0, out = 0; out < live_argument_regs.size(); ++out) {
-      size_t size = live_argument_regs_size.at(out);
-      if (IsRegisterPair(instruction_set, live_argument_regs.at(out))) {
-        CHECK_EQ(instruction_set, kArm);
-        arm::ArmManagedRegister pair(live_argument_regs.at(out).AsArm());
-        arm::Register lo(pair.AsRegisterPairLow());
-        arm::Register hi(pair.AsRegisterPairHigh());
-        __ Move(arm::ArmManagedRegister::FromCoreRegister(lo), callee_save_regs.at(in++), size / 2);
-        __ Move(arm::ArmManagedRegister::FromCoreRegister(hi), callee_save_regs.at(in++), size / 2);
-      } else {
-        __ Move(live_argument_regs.at(out), callee_save_regs.at(in++), size);
-      }
-    }
-  }
-
-  // 7. Iterate over arguments placing values from managed calling convention in
-  //    to the convention required for a native call (shuffling). For references
-  //    place an index/pointer to the reference after checking whether it is
-  //    NULL (which must be encoded as NULL).
-  //    Note: we do this prior to materializing the JNIEnv* and static's jclass to
-  //    give as many free registers for the shuffle as possible
-  mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size));
-  uint32_t args_count = 0;
-  while (mr_conv->HasNext()) {
-    args_count++;
-    mr_conv->Next();
-  }
-
-  // Do a backward pass over arguments, so that the generated code will be "mov
-  // R2, R3; mov R1, R2" instead of "mov R1, R2; mov R2, R3."
-  // TODO: A reverse iterator to improve readability.
-  for (uint32_t i = 0; i < args_count; ++i) {
-    mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size));
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    jni_conv->Next();  // Skip JNIEnv*
-    if (is_static) {
-      jni_conv->Next();  // Skip Class for now
-    }
-    for (uint32_t j = 0; j < args_count - i - 1; ++j) {
-      mr_conv->Next();
-      jni_conv->Next();
-    }
-    CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size, out_arg_size);
-  }
-
-  if (is_static) {
-    // Create argument for Class
-    mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size));
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    jni_conv->Next();  // Skip JNIEnv*
-    FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
-    if (jni_conv->IsCurrentParamOnStack()) {
-      FrameOffset out_off = jni_conv->CurrentParamStackOffset();
-      __ CreateSirtEntry(out_off, sirt_offset,
-                         mr_conv->InterproceduralScratchRegister(),
-                         false);
-    } else {
-      ManagedRegister out_reg = jni_conv->CurrentParamRegister();
-      __ CreateSirtEntry(out_reg, sirt_offset,
-                         ManagedRegister::NoRegister(), false);
-    }
-  }
-  // 8. Create 1st argument, the JNI environment ptr and save the top of the local reference table
-  jni_conv->ResetIterator(FrameOffset(out_arg_size));
-  // Register that will hold local indirect reference table
-  if (jni_conv->IsCurrentParamInRegister()) {
-    ManagedRegister jni_env = jni_conv->CurrentParamRegister();
-    DCHECK(!jni_env.Equals(jni_conv->InterproceduralScratchRegister()));
-    __ LoadRawPtrFromThread(jni_env, Thread::JniEnvOffset());
-    // Frame[saved_local_ref_cookie_offset] = env->local_ref_cookie
-    __ Copy(jni_conv->SavedLocalReferenceCookieOffset(),
-            jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_conv->InterproceduralScratchRegister(), 4);
-    // env->local_ref_cookie = env->locals.segment_state
-    __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_env, JNIEnvExt::SegmentStateOffset(),
-            jni_conv->InterproceduralScratchRegister(), 4);
-  } else {
-    FrameOffset jni_env = jni_conv->CurrentParamStackOffset();
-    __ CopyRawPtrFromThread(jni_env, Thread::JniEnvOffset(),
-                            jni_conv->InterproceduralScratchRegister());
-    // Frame[saved_local_ref_cookie_offset] = env->local_ref_cookie
-    __ Copy(jni_conv->SavedLocalReferenceCookieOffset(),
-            jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_conv->InterproceduralScratchRegister(), 4);
-    // env->local_ref_cookie = env->locals.segment_state
-    __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_env, JNIEnvExt::SegmentStateOffset(),
-            jni_conv->InterproceduralScratchRegister(), 4);
-  }
-
-  // 9. Plant call to native code associated with method
-  if (!jni_conv->IsMethodRegisterClobberedPreCall()) {
-    // Method register shouldn't have been crushed by setting up outgoing
-    // arguments
-    __ Call(mr_conv->MethodRegister(), Method::NativeMethodOffset(),
-            mr_conv->InterproceduralScratchRegister());
-  } else {
-    __ Call(jni_conv->MethodStackOffset(), Method::NativeMethodOffset(),
-            mr_conv->InterproceduralScratchRegister());
-  }
-
-  // 10. Release lock for synchronized methods.
-  if (is_synchronized) {
-    mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size));
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    jni_conv->Next();  // Skip JNIEnv*
-    // Save return value
-    FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation();
-    if (jni_conv->SizeOfReturnValue() != 0) {
-      FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation();
-      CHECK_LT(return_save_location.Uint32Value(), frame_size+out_arg_size);
-      __ Store(return_save_location, jni_conv->ReturnRegister(),
-               jni_conv->SizeOfReturnValue());
-    }
-    // Get SIRT entry for 1st argument
-    if (is_static) {
-      FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset();
-      if (jni_conv->IsCurrentParamOnStack()) {
-        FrameOffset out_off = jni_conv->CurrentParamStackOffset();
-        __ CreateSirtEntry(out_off, sirt_offset,
-                           mr_conv->InterproceduralScratchRegister(),
-                           false);
-      } else {
-        ManagedRegister out_reg = jni_conv->CurrentParamRegister();
-        __ CreateSirtEntry(out_reg, sirt_offset,
-                           ManagedRegister::NoRegister(), false);
-      }
-    } else {
-      CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size,
-                    out_arg_size);
-    }
-    // Generate JNIEnv* in place and leave a copy in jni_env_register
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    ManagedRegister jni_env_register =
-        jni_conv->InterproceduralScratchRegister();
-    __ LoadRawPtrFromThread(jni_env_register, Thread::JniEnvOffset());
-    SetNativeParameter(jni_asm.get(), jni_conv.get(), jni_env_register);
-    // Call JNIEnv->MonitorExit(object)
-    __ LoadRawPtr(jni_env_register, jni_env_register, functions);
-    __ Call(jni_env_register, monitor_exit,
-            jni_conv->InterproceduralScratchRegister());
-    // Reload return value
-    if (jni_conv->SizeOfReturnValue() != 0) {
-      __ Load(jni_conv->ReturnRegister(), return_save_location,
-              jni_conv->SizeOfReturnValue());
-    }
-  }
-
-  // 11. Release outgoing argument area
-  __ DecreaseFrameSize(out_arg_size);
-  mr_conv->ResetIterator(FrameOffset(frame_size));
-  jni_conv->ResetIterator(FrameOffset(0));
-
-  // 12. Transition from being in native to managed code, possibly entering a
-  //     safepoint
-  // Don't clobber result
-  CHECK(!jni_conv->InterproceduralScratchRegister().Equals(jni_conv->ReturnRegister()));
-  // Location to preserve result on slow path, ensuring its within the frame
-  FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation();
-  CHECK(return_save_location.Uint32Value() < frame_size ||
-        jni_conv->SizeOfReturnValue() == 0);
-  ChangeThreadState(jni_asm.get(), kRunnable,
-                    jni_conv->InterproceduralScratchRegister(),
-                    jni_conv->ReturnRegister(), return_save_location,
-                    jni_conv->SizeOfReturnValue());
-
-  // 13. Place result in correct register possibly loading from indirect
-  //     reference table
-  if (jni_conv->IsReturnAReference()) {
-    __ IncreaseFrameSize(out_arg_size);
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-
-    jni_conv->Next();  // Skip Thread* argument
-    // Pass result as arg2
-    SetNativeParameter(jni_asm.get(), jni_conv.get(),
-                       jni_conv->ReturnRegister());
-
-    // Pass Thread*
-    jni_conv->ResetIterator(FrameOffset(out_arg_size));
-    if (jni_conv->IsCurrentParamInRegister()) {
-      __ GetCurrentThread(jni_conv->CurrentParamRegister());
-      __ Call(jni_conv->CurrentParamRegister(),
-              Offset(ENTRYPOINT_OFFSET(pDecodeJObjectInThread)),
-              jni_conv->InterproceduralScratchRegister());
-    } else {
-      __ GetCurrentThread(jni_conv->CurrentParamStackOffset(),
-                          jni_conv->InterproceduralScratchRegister());
-      __ Call(ThreadOffset(ENTRYPOINT_OFFSET(pDecodeJObjectInThread)),
-              jni_conv->InterproceduralScratchRegister());
-    }
-
-    __ DecreaseFrameSize(out_arg_size);
-    jni_conv->ResetIterator(FrameOffset(0));
-  } else if (instruction_set == kX86) {
-    if (jni_conv->GetReturnType() == Primitive::kPrimByte ||
-        jni_conv->GetReturnType() == Primitive::kPrimShort) {
-      __ SignExtend(jni_conv->ReturnRegister(), Primitive::ComponentSize(jni_conv->GetReturnType()));
-    } else if (jni_conv->GetReturnType() == Primitive::kPrimBoolean ||
-               jni_conv->GetReturnType() == Primitive::kPrimChar) {
-      __ ZeroExtend(jni_conv->ReturnRegister(), Primitive::ComponentSize(jni_conv->GetReturnType()));
-    }
-  }
-  DCHECK_EQ(mr_conv->SizeOfReturnValue(), jni_conv->SizeOfReturnValue());
-  __ Move(mr_conv->ReturnRegister(), jni_conv->ReturnRegister(), mr_conv->SizeOfReturnValue());
-
-  // 14. Restore segment state and remove SIRT from thread
-  {
-    ManagedRegister jni_env = jni_conv->InterproceduralScratchRegister();
-    __ LoadRawPtrFromThread(jni_env, Thread::JniEnvOffset());
-    // env->locals.segment_state = env->local_ref_cookie
-    __ Copy(jni_env, JNIEnvExt::SegmentStateOffset(),
-            jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_conv->ReturnScratchRegister(), 4);
-    // env->local_ref_cookie = Frame[saved_local_ref_cookie_offset]
-    __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(),
-            jni_conv->SavedLocalReferenceCookieOffset(),
-            jni_conv->ReturnScratchRegister(), 4);
-  }
-  __ CopyRawPtrToThread(Thread::TopSirtOffset(), jni_conv->SirtLinkOffset(),
-                        jni_conv->InterproceduralScratchRegister());
-
-  // 15. Check for pending exception and forward if there
-  __ ExceptionPoll(jni_conv->InterproceduralScratchRegister());
-
-  // 16. Remove activation
-  if (is_synchronized) {
-    __ RemoveFrame(frame_size, callee_save_regs);
-  } else {
-    // no need to restore callee save registers because we didn't
-    // clobber them while locking the monitor.
-    __ RemoveFrame(frame_size, std::vector<ManagedRegister>());
-  }
-
-  // 17. Finalize code generation
-  __ EmitSlowPaths();
-  size_t cs = __ CodeSize();
-  std::vector<uint8_t> managed_code(cs);
-  MemoryRegion code(&managed_code[0], managed_code.size());
-  __ FinalizeInstructions(code);
-  if (should_disassemble) {
-    UniquePtr<Disassembler> disassembler(Disassembler::Create(instruction_set));
-    disassembler->Dump(LOG(INFO), &managed_code[0], &managed_code[managed_code.size()]);
-  }
-  return new CompiledMethod(instruction_set,
-                            managed_code,
-                            frame_size,
-                            jni_conv->CoreSpillMask(),
-                            jni_conv->FpSpillMask());
-}
-
 }  // namespace art
 
 extern "C" art::CompiledMethod* ArtJniCompileMethod(art::Compiler& compiler,
diff --git a/src/oat/jni/x86/calling_convention_x86.cc b/src/oat/jni/x86/calling_convention_x86.cc
index 1cd849c..90c050c 100644
--- a/src/oat/jni/x86/calling_convention_x86.cc
+++ b/src/oat/jni/x86/calling_convention_x86.cc
@@ -61,6 +61,10 @@
   return ReturnRegisterForShorty(GetShorty(), true);
 }
 
+ManagedRegister X86JniCallingConvention::IntReturnRegister() {
+  return X86ManagedRegister::FromCpuRegister(EAX);
+}
+
 // Managed runtime calling convention
 
 ManagedRegister X86ManagedRuntimeCallingConvention::MethodRegister() {
@@ -131,10 +135,6 @@
   return RoundUp(NumberOfOutgoingStackArgs() * kPointerSize, kStackAlignment);
 }
 
-bool X86JniCallingConvention::IsMethodRegisterClobberedPreCall() {
-  return IsSynchronized();  // Monitor enter crushes the method register
-}
-
 bool X86JniCallingConvention::IsCurrentParamInRegister() {
   return false;  // Everything is passed by stack.
 }
@@ -149,15 +149,17 @@
 }
 
 FrameOffset X86JniCallingConvention::CurrentParamStackOffset() {
-  return FrameOffset(displacement_.Int32Value() - OutArgSize() +
-                     (itr_slots_ * kPointerSize));
+  return FrameOffset(displacement_.Int32Value() - OutArgSize() + (itr_slots_ * kPointerSize));
 }
 
 size_t X86JniCallingConvention::NumberOfOutgoingStackArgs() {
   size_t static_args = IsStatic() ? 1 : 0;  // count jclass
   // regular argument parameters and this
   size_t param_args = NumArgs() + NumLongOrDoubleArgs();
-  return static_args + param_args + 2;  // count JNIEnv* and return pc (pushed after Method*)
+  // count JNIEnv* and return pc (pushed after Method*)
+  size_t total_args = static_args + param_args + 2;
+  return total_args;
+
 }
 
 }  // namespace x86
diff --git a/src/oat/jni/x86/calling_convention_x86.h b/src/oat/jni/x86/calling_convention_x86.h
index 959a37f..5116a46 100644
--- a/src/oat/jni/x86/calling_convention_x86.h
+++ b/src/oat/jni/x86/calling_convention_x86.h
@@ -49,6 +49,7 @@
   virtual ~X86JniCallingConvention() {}
   // Calling convention
   virtual ManagedRegister ReturnRegister();
+  virtual ManagedRegister IntReturnRegister();
   virtual ManagedRegister InterproceduralScratchRegister();
   // JNI calling convention
   virtual size_t FrameSize();
@@ -61,7 +62,6 @@
   virtual uint32_t FpSpillMask() const {
     return 0;
   }
-  virtual bool IsMethodRegisterClobberedPreCall();
   virtual bool IsCurrentParamInRegister();
   virtual bool IsCurrentParamOnStack();
   virtual ManagedRegister CurrentParamRegister();
diff --git a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
index 37454fd..1aa069e 100644
--- a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
+++ b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
@@ -60,8 +60,17 @@
 extern "C" void art_handle_fill_data_from_code(void*, void*);
 
 // JNI entrypoints.
-extern Object* DecodeJObjectInThread(Thread* thread, jobject obj);
 extern void* FindNativeMethod(Thread* thread);
+extern uint32_t JniMethodStart(Thread* self);
+extern uint32_t JniMethodStartSynchronized(jobject to_lock, Thread* self);
+extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self);
+extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie, jobject locked,
+                                     Thread* self);
+extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+                                         Thread* self);
+extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
+                                                     uint32_t saved_local_ref_cookie,
+                                                     jobject locked, Thread* self);
 
 // Lock entrypoints.
 extern "C" void art_lock_object_from_code(void*);
@@ -182,8 +191,13 @@
   points->pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
 
   // JNI
-  points->pDecodeJObjectInThread = DecodeJObjectInThread;
   points->pFindNativeMethod = FindNativeMethod;
+  points->pJniMethodStart = JniMethodStart;
+  points->pJniMethodStartSynchronized = JniMethodStartSynchronized;
+  points->pJniMethodEnd = JniMethodEnd;
+  points->pJniMethodEndSynchronized = JniMethodEndSynchronized;
+  points->pJniMethodEndWithReference = JniMethodEndWithReference;
+  points->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
   points->pLockObjectFromCode = art_lock_object_from_code;
diff --git a/src/oat/runtime/arm/stub_arm.cc b/src/oat/runtime/arm/stub_arm.cc
index 5a20748..d3c94a8 100644
--- a/src/oat/runtime/arm/stub_arm.cc
+++ b/src/oat/runtime/arm/stub_arm.cc
@@ -17,6 +17,7 @@
 #include "jni_internal.h"
 #include "oat/utils/arm/assembler_arm.h"
 #include "oat/runtime/oat_support_entrypoints.h"
+#include "oat/runtime/stub.h"
 #include "object.h"
 #include "stack_indirect_reference_table.h"
 
diff --git a/src/oat/runtime/callee_save_frame.h b/src/oat/runtime/callee_save_frame.h
index 1509553..14ba046 100644
--- a/src/oat/runtime/callee_save_frame.h
+++ b/src/oat/runtime/callee_save_frame.h
@@ -23,9 +23,11 @@
 
 class Method;
 
-// 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
+// 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)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  // Be aware the store below may well stomp on an incoming argument.
+  GlobalSynchronization::mutator_lock_->AssertSharedHeld();
   *sp = Runtime::Current()->GetCalleeSaveMethod(type);
   self->SetTopOfStack(sp, 0);
   self->VerifyStack();
diff --git a/src/oat/runtime/oat_support_entrypoints.h b/src/oat/runtime/oat_support_entrypoints.h
index a235e4f..39d9eab 100644
--- a/src/oat/runtime/oat_support_entrypoints.h
+++ b/src/oat/runtime/oat_support_entrypoints.h
@@ -72,8 +72,14 @@
   void (*pHandleFillArrayDataFromCode)(void*, void*);
 
   // JNI
-  Object* (*pDecodeJObjectInThread)(Thread* thread, jobject obj);
   void* (*pFindNativeMethod)(Thread* thread);
+  uint32_t (*pJniMethodStart)(Thread*);
+  uint32_t (*pJniMethodStartSynchronized)(jobject to_lock, Thread* self);
+  void (*pJniMethodEnd)(uint32_t cookie, Thread* self);
+  void (*pJniMethodEndSynchronized)(uint32_t cookie, jobject locked, Thread* self);
+  Object* (*pJniMethodEndWithReference)(jobject result, uint32_t cookie, Thread* self);
+  Object* (*pJniMethodEndWithReferenceSynchronized)(jobject result, uint32_t cookie,
+                                                    jobject locked, Thread* self);
 
   // Locks
   void (*pLockObjectFromCode)(void*);
diff --git a/src/oat/runtime/stub.h b/src/oat/runtime/stub.h
new file mode 100644
index 0000000..5d8b37d
--- /dev/null
+++ b/src/oat/runtime/stub.h
@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+#ifndef ART_SRC_OAT_RUNTIME_OAT_RUNTIME_STUB_H_
+#define ART_SRC_OAT_RUNTIME_OAT_RUNTIME_STUB_H_
+
+#include "runtime.h"
+
+namespace art {
+
+namespace arm {
+  ByteArray* CreateAbstractMethodErrorStub()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  ByteArray* CreateJniDlsymLookupStub()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+}
+
+namespace x86 {
+  ByteArray* CreateAbstractMethodErrorStub()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  ByteArray* CreateJniDlsymLookupStub()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+}
+
+}  // namespace art
+
+#endif  // ART_SRC_OAT_RUNTIME_OAT_RUNTIME_STUB_H_
diff --git a/src/oat/runtime/support_alloc.cc b/src/oat/runtime/support_alloc.cc
index d9394d2..4a03f98 100644
--- a/src/oat/runtime/support_alloc.cc
+++ b/src/oat/runtime/support_alloc.cc
@@ -20,39 +20,45 @@
 namespace art {
 
 extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method,
-                                          Thread* self, Method** sp) {
+                                          Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocObjectFromCode(type_idx, method, self, false);
 }
 
 extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
-                                                         Thread* self, Method** sp) {
+                                                         Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocObjectFromCode(type_idx, method, self, true);
 }
 
 extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
-                                        Thread* self, Method** sp) {
+                                        Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocArrayFromCode(type_idx, method, component_count, self, false);
 }
 
 extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
                                                        int32_t component_count,
-                                                       Thread* self, Method** sp) {
+                                                       Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return AllocArrayFromCode(type_idx, method, component_count, self, true);
 }
 
 extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
-                                               int32_t component_count, Thread* self, Method** sp) {
+                                               int32_t component_count, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, false);
 }
 
 extern "C" Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
                                                                int32_t component_count,
-                                                               Thread* self, Method** sp) {
+                                                               Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, true);
 }
diff --git a/src/oat/runtime/support_cast.cc b/src/oat/runtime/support_cast.cc
index 139239f..ea083f1 100644
--- a/src/oat/runtime/support_cast.cc
+++ b/src/oat/runtime/support_cast.cc
@@ -20,14 +20,16 @@
 namespace art {
 
 // Assignable test for code, won't throw.  Null and equality tests already performed
-extern "C" uint32_t artIsAssignableFromCode(const Class* klass, const Class* ref_class) {
+extern "C" uint32_t artIsAssignableFromCode(const Class* klass, const Class* ref_class)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   DCHECK(klass != NULL);
   DCHECK(ref_class != NULL);
   return klass->IsAssignableFrom(ref_class) ? 1 : 0;
 }
 
 // Check whether it is safe to cast one class to the other, throw exception and return -1 on failure
-extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self, Method** sp) {
+extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   DCHECK(a->IsClass()) << PrettyClass(a);
   DCHECK(b->IsClass()) << PrettyClass(b);
   if (LIKELY(b->IsAssignableFrom(a))) {
@@ -45,7 +47,8 @@
 // Tests whether 'element' can be assigned into an array of type 'array_class'.
 // Returns 0 on success and -1 if an exception is pending.
 extern "C" int artCanPutArrayElementFromCode(const Object* element, const Class* array_class,
-                                             Thread* self, Method** sp) {
+                                             Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   DCHECK(array_class != NULL);
   // element can't be NULL as we catch this is screened in runtime_support
   Class* element_class = element->GetClass();
diff --git a/src/oat/runtime/support_debug.cc b/src/oat/runtime/support_debug.cc
index ef6e0b1..9968043 100644
--- a/src/oat/runtime/support_debug.cc
+++ b/src/oat/runtime/support_debug.cc
@@ -25,13 +25,15 @@
  * method entry and offset 0 within the method, we'll use an offset of -1
  * to denote method entry.
  */
-extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, Method** sp) {
+extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp,  Runtime::kRefsAndArgs);
   Dbg::UpdateDebugger(dex_pc, self);
 }
 
 // Temporary debugging hook for compiler.
-extern void DebugMe(Method* method, uint32_t info) {
+extern void DebugMe(Method* method, uint32_t info)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   LOG(INFO) << "DebugMe";
   if (method != NULL) {
     LOG(INFO) << PrettyMethod(method);
diff --git a/src/oat/runtime/support_dexcache.cc b/src/oat/runtime/support_dexcache.cc
index 49e038d..8e7c2ad 100644
--- a/src/oat/runtime/support_dexcache.cc
+++ b/src/oat/runtime/support_dexcache.cc
@@ -20,7 +20,8 @@
 namespace art {
 
 extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const Method* referrer,
-                                                     Thread* self, Method** sp) {
+                                                     Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Called to ensure static storage base is initialized for direct static field reads and writes.
   // A class may be accessing another class' fields when it doesn't have access, as access has been
   // given by inheritance.
@@ -29,7 +30,8 @@
 }
 
 extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const Method* referrer, Thread* self,
-                                            Method** sp) {
+                                            Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Called when method->dex_cache_resolved_types_[] misses.
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return ResolveVerifyAndClinit(type_idx, referrer, self, false, false);
@@ -37,7 +39,8 @@
 
 extern "C" Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
                                                            const Method* referrer, Thread* self,
-                                                           Method** sp) {
+                                                           Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Called when caller isn't guaranteed to have access to a type and the dex cache may be
   // unpopulated.
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
@@ -45,7 +48,8 @@
 }
 
 extern "C" String* artResolveStringFromCode(Method* referrer, int32_t string_idx,
-                                            Thread* self, Method** sp) {
+                                            Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   return ResolveStringFromCode(referrer, string_idx);
 }
diff --git a/src/oat/runtime/support_field.cc b/src/oat/runtime/support_field.cc
index 77fe618..99e3a94 100644
--- a/src/oat/runtime/support_field.cc
+++ b/src/oat/runtime/support_field.cc
@@ -22,7 +22,8 @@
 namespace art {
 
 extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
+                                           Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     return field->Get32(NULL);
@@ -36,7 +37,8 @@
 }
 
 extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
+                                           Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     return field->Get64(NULL);
@@ -50,7 +52,8 @@
 }
 
 extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
-                                           Thread* self, Method** sp) {
+                                           Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
   if (LIKELY(field != NULL)) {
     return field->GetObj(NULL);
@@ -64,7 +67,8 @@
 }
 
 extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp) {
+                                             const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->Get32(obj);
@@ -82,7 +86,8 @@
 }
 
 extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
-                                             const Method* referrer, Thread* self, Method** sp) {
+                                             const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->Get64(obj);
@@ -100,7 +105,8 @@
 }
 
 extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
-                                              const Method* referrer, Thread* self, Method** sp) {
+                                              const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
   if (LIKELY(field != NULL && obj != NULL)) {
     return field->GetObj(obj);
@@ -118,7 +124,8 @@
 }
 
 extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
-                                      const Method* referrer, Thread* self, Method** sp) {
+                                      const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
   if (LIKELY(field != NULL)) {
     field->Set32(NULL, new_value);
@@ -134,7 +141,8 @@
 }
 
 extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
-                                      uint64_t new_value, Thread* self, Method** sp) {
+                                      uint64_t new_value, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
   if (LIKELY(field != NULL)) {
     field->Set64(NULL, new_value);
@@ -150,7 +158,8 @@
 }
 
 extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
-                                       const Method* referrer, Thread* self, Method** sp) {
+                                       const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
   if (LIKELY(field != NULL)) {
     if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
@@ -168,7 +177,8 @@
 }
 
 extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
-                                        const Method* referrer, Thread* self, Method** sp) {
+                                        const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
   if (LIKELY(field != NULL && obj != NULL)) {
     field->Set32(obj, new_value);
@@ -188,7 +198,8 @@
 }
 
 extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
-                                        Thread* self, Method** sp) {
+                                        Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   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));
@@ -211,7 +222,8 @@
 }
 
 extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
-                                         const Method* referrer, Thread* self, Method** sp) {
+                                         const Method* referrer, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
   if (LIKELY(field != NULL && obj != NULL)) {
     field->SetObj(obj, new_value);
diff --git a/src/oat/runtime/support_fillarray.cc b/src/oat/runtime/support_fillarray.cc
index 7227f6b..8561bd8 100644
--- a/src/oat/runtime/support_fillarray.cc
+++ b/src/oat/runtime/support_fillarray.cc
@@ -37,7 +37,8 @@
  */
 extern "C" int artHandleFillArrayDataFromCode(Array* array,
                                               const Instruction::ArrayDataPayload* payload,
-                                              Thread* self, Method** sp) {
+                                              Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   DCHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature));
   if (UNLIKELY(array == NULL)) {
diff --git a/src/oat/runtime/support_invoke.cc b/src/oat/runtime/support_invoke.cc
index 4669688..9c7b3a2 100644
--- a/src/oat/runtime/support_invoke.cc
+++ b/src/oat/runtime/support_invoke.cc
@@ -20,7 +20,8 @@
 namespace art {
 
 static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
-                                Thread* self, Method** sp, bool access_check, InvokeType type) {
+                                Thread* self, Method** sp, bool access_check, InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
   if (UNLIKELY(method == NULL)) {
     FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
@@ -54,14 +55,16 @@
 // See comments in runtime_support_asm.S
 extern "C" uint64_t artInvokeInterfaceTrampoline(uint32_t method_idx, Object* this_object,
                                                  Method* caller_method, Thread* self,
-                                                 Method** sp) {
+                                                 Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, false, kInterface);
 }
 
 extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
                                                                 Object* this_object,
                                                                 Method* caller_method, Thread* self,
-                                                                Method** sp) {
+                                                                Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kInterface);
 }
 
@@ -69,28 +72,32 @@
 extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
                                                              Object* this_object,
                                                              Method* caller_method, Thread* self,
-                                                             Method** sp) {
+                                                             Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kDirect);
 }
 
 extern "C" uint64_t artInvokeStaticTrampolineWithAccessCheck(uint32_t method_idx,
                                                             Object* this_object,
                                                             Method* caller_method, Thread* self,
-                                                            Method** sp) {
+                                                            Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kStatic);
 }
 
 extern "C" uint64_t artInvokeSuperTrampolineWithAccessCheck(uint32_t method_idx,
                                                             Object* this_object,
                                                             Method* caller_method, Thread* self,
-                                                            Method** sp) {
+                                                            Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kSuper);
 }
 
 extern "C" uint64_t artInvokeVirtualTrampolineWithAccessCheck(uint32_t method_idx,
                                                               Object* this_object,
                                                               Method* caller_method, Thread* self,
-                                                              Method** sp) {
+                                                              Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kVirtual);
 }
 
diff --git a/src/oat/runtime/support_jni.cc b/src/oat/runtime/support_jni.cc
index cfa1a11..bbff673 100644
--- a/src/oat/runtime/support_jni.cc
+++ b/src/oat/runtime/support_jni.cc
@@ -16,20 +16,23 @@
 
 #include "object.h"
 #include "object_utils.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 
 namespace art {
 
 // Used by the JNI dlsym stub to find the native method to invoke if none is registered.
-extern void* FindNativeMethod(Thread* self) {
+extern void* FindNativeMethod(Thread* self) LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_) {
+  GlobalSynchronization::mutator_lock_->AssertNotHeld();  // We come here as Native.
   DCHECK(Thread::Current() == self);
+  ScopedObjectAccess soa(self);
 
-  Method* method = const_cast<Method*>(self->GetCurrentMethod());
+  Method* 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 = self->GetJniEnv()->vm->FindCodeForNativeMethod(method);
+  void* native_code = soa.Vm()->FindCodeForNativeMethod(method);
   if (native_code == NULL) {
     DCHECK(self->IsExceptionPending());
     return NULL;
@@ -40,23 +43,61 @@
   }
 }
 
-// Return value helper for jobject return types, used for JNI return values.
-extern Object* DecodeJObjectInThread(Thread* self, jobject java_object) {
-  if (self->IsExceptionPending()) {
-    return NULL;
-  }
-  Object* o = self->DecodeJObject(java_object);
-  if (o == NULL || !self->GetJniEnv()->check_jni) {
-    return o;
-  }
+// Called on entry to JNI, transition out of Runnable and release share of mutator_lock_.
+extern uint32_t JniMethodStart(Thread* self) UNLOCK_FUNCTION(GlobalSynchronizatio::mutator_lock_) {
+  JNIEnvExt* env = self->GetJniEnv();
+  uint32_t saved_local_ref_cookie = env->local_ref_cookie;
+  env->local_ref_cookie = env->locals.GetSegmentState();
+  self->TransitionFromRunnableToSuspended(kNative);
+  return saved_local_ref_cookie;
+}
 
+extern uint32_t JniMethodStartSynchronized(jobject to_lock, Thread* self)
+    UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+  self->DecodeJObject(to_lock)->MonitorEnter(self);
+  return JniMethodStart(self);
+}
+
+static void PopLocalReferences(uint32_t saved_local_ref_cookie, Thread* self) {
+  JNIEnvExt* env = self->GetJniEnv();
+  env->locals.SetSegmentState(env->local_ref_cookie);
+  env->local_ref_cookie = saved_local_ref_cookie;
+  self->PopSirt();
+}
+
+static void UnlockJniSynchronizedMethod(jobject locked, Thread* self)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+    UNLOCK_FUNCTION(monitor_lock_) {
+  // Save any pending exception over monitor exit call.
+  Throwable* saved_exception = NULL;
+  if (UNLIKELY(self->IsExceptionPending())) {
+    saved_exception = self->GetException();
+    self->ClearException();
+  }
+  // Decode locked object and unlock, before popping local references.
+  self->DecodeJObject(locked)->MonitorExit(self);
+  if (UNLIKELY(self->IsExceptionPending())) {
+    LOG(FATAL) << "Synchronized JNI code returning with an exception:\n"
+        << saved_exception->Dump()
+        << "\nEncountered second exception during implicit MonitorExit:\n"
+        << self->GetException()->Dump();
+  }
+  // Restore pending exception.
+  if (saved_exception != NULL) {
+    self->SetException(saved_exception);
+  }
+}
+
+static void CheckReferenceResult(Object* o, Thread* self)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  if (o == NULL) {
+    return;
+  }
   if (o == kInvalidIndirectRefObject) {
     JniAbortF(NULL, "invalid reference returned from %s",
               PrettyMethod(self->GetCurrentMethod()).c_str());
   }
-
-  // Make sure that the result is an instance of the type this
-  // method was expected to return.
+  // Make sure that the result is an instance of the type this method was expected to return.
   Method* m = self->GetCurrentMethod();
   MethodHelper mh(m);
   Class* return_type = mh.GetReturnType();
@@ -65,7 +106,53 @@
     JniAbortF(NULL, "attempt to return an instance of %s from %s",
               PrettyTypeOf(o).c_str(), PrettyMethod(m).c_str());
   }
+}
 
+extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self)
+    SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+  self->TransitionFromSuspendedToRunnable();
+  PopLocalReferences(saved_local_ref_cookie, self);
+}
+
+
+extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie, jobject locked, Thread* self)
+    SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+  self->TransitionFromSuspendedToRunnable();
+  UnlockJniSynchronizedMethod(locked, self);  // Must decode before pop.
+  PopLocalReferences(saved_local_ref_cookie, self);
+}
+
+extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+                                         Thread* self)
+    SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+  self->TransitionFromSuspendedToRunnable();
+  Object* o = self->DecodeJObject(result);  // Must decode before pop.
+  PopLocalReferences(saved_local_ref_cookie, self);
+  // Process result.
+  if (UNLIKELY(self->GetJniEnv()->check_jni)) {
+    if (self->IsExceptionPending()) {
+      return NULL;
+    }
+    CheckReferenceResult(o, self);
+  }
+  return o;
+}
+
+extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
+                                                     uint32_t saved_local_ref_cookie,
+                                                     jobject locked, Thread* self)
+    SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+  self->TransitionFromSuspendedToRunnable();
+  UnlockJniSynchronizedMethod(locked, self);  // Must decode before pop.
+  Object* o = self->DecodeJObject(result);
+  PopLocalReferences(saved_local_ref_cookie, self);
+  // Process result.
+  if (UNLIKELY(self->GetJniEnv()->check_jni)) {
+    if (self->IsExceptionPending()) {
+      return NULL;
+    }
+    CheckReferenceResult(o, self);
+  }
   return o;
 }
 
@@ -77,7 +164,8 @@
   *arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
 }
 
-extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp) {
+extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_){
   DCHECK(Thread::Current() == self);
   // TODO: this code is specific to ARM
   // On entry the stack pointed by sp is:
diff --git a/src/oat/runtime/support_locks.cc b/src/oat/runtime/support_locks.cc
index 30fc567..9d44e55 100644
--- a/src/oat/runtime/support_locks.cc
+++ b/src/oat/runtime/support_locks.cc
@@ -19,14 +19,16 @@
 
 namespace art {
 
-extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp) {
+extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp)
+    UNLOCK_FUNCTION(monitor_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
   DCHECK(obj != NULL);  // Assumed to have been checked before entry
   // MonitorExit may throw exception
   return obj->MonitorExit(self) ? 0 /* Success */ : -1 /* Failure */;
 }
 
-extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, Method** sp) {
+extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, Method** sp)
+    EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
   DCHECK(obj != NULL);        // Assumed to have been checked before entry
   obj->MonitorEnter(thread);  // May block
diff --git a/src/oat/runtime/support_proxy.cc b/src/oat/runtime/support_proxy.cc
index 83d2265..972779d 100644
--- a/src/oat/runtime/support_proxy.cc
+++ b/src/oat/runtime/support_proxy.cc
@@ -18,7 +18,7 @@
 #include "object_utils.h"
 #include "reflection.h"
 #include "runtime_support.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "well_known_classes.h"
 
@@ -43,7 +43,8 @@
 // reference arguments (so they survive GC) and create a boxed argument array. Finally we invoke
 // the invocation handler which is a field within the proxy object receiver.
 extern "C" void artProxyInvokeHandler(Method* proxy_method, Object* receiver,
-                                      Thread* self, byte* stack_args) {
+                                      Thread* self, byte* stack_args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Register the top of the managed stack
   Method** proxy_sp = reinterpret_cast<Method**>(stack_args - SP_OFFSET_IN_BYTES);
   DCHECK_EQ(*proxy_sp, proxy_method);
@@ -51,11 +52,11 @@
   DCHECK_EQ(proxy_method->GetFrameSizeInBytes(), FRAME_SIZE_IN_BYTES);
   // Start new JNI local reference state
   JNIEnvExt* env = self->GetJniEnv();
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccessUnchecked soa(env);
   ScopedJniEnvLocalRefState env_state(env);
   // Create local ref. copies of proxy method and the receiver
-  jobject rcvr_jobj = ts.AddLocalReference<jobject>(receiver);
-  jobject proxy_method_jobj = ts.AddLocalReference<jobject>(proxy_method);
+  jobject rcvr_jobj = soa.AddLocalReference<jobject>(receiver);
+  jobject proxy_method_jobj = soa.AddLocalReference<jobject>(proxy_method);
 
   // Placing into local references incoming arguments from the caller's register arguments,
   // replacing original Object* with jobject
@@ -74,7 +75,7 @@
   while (cur_arg < args_in_regs && param_index < num_params) {
     if (proxy_mh.IsParamAReference(param_index)) {
       Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
-      jobject jobj = ts.AddLocalReference<jobject>(obj);
+      jobject jobj = soa.AddLocalReference<jobject>(obj);
       *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
     }
     cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
@@ -85,7 +86,7 @@
   while (param_index < num_params) {
     if (proxy_mh.IsParamAReference(param_index)) {
       Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
-      jobject jobj = ts.AddLocalReference<jobject>(obj);
+      jobject jobj = soa.AddLocalReference<jobject>(obj);
       *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
     }
     cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
@@ -104,13 +105,13 @@
       CHECK(self->IsExceptionPending());
       return;
     }
-    args_jobj[2].l = ts.AddLocalReference<jobjectArray>(args);
+    args_jobj[2].l = soa.AddLocalReference<jobjectArray>(args);
   }
   // Convert proxy method into expected interface method
   Method* interface_method = proxy_method->FindOverriddenMethod();
   DCHECK(interface_method != NULL);
   DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
-  args_jobj[1].l = ts.AddLocalReference<jobject>(interface_method);
+  args_jobj[1].l = soa.AddLocalReference<jobject>(interface_method);
   // Box arguments
   cur_arg = 0;  // reset stack location to read to start
   // reset index, will index into param type array which doesn't include the receiver
diff --git a/src/oat/runtime/support_stubs.cc b/src/oat/runtime/support_stubs.cc
index 3f6bc8f..013f885 100644
--- a/src/oat/runtime/support_stubs.cc
+++ b/src/oat/runtime/support_stubs.cc
@@ -23,7 +23,7 @@
 #if defined(ART_USE_LLVM_COMPILER)
 #include "nth_caller_visitor.h"
 #endif
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 
 // Architecture specific assembler helper to deliver exception.
 extern "C" void art_deliver_exception_from_code(void*);
@@ -33,7 +33,8 @@
 #if !defined(ART_USE_LLVM_COMPILER)
 // Lazily resolve a method. Called by stub code.
 const void* UnresolvedDirectMethodTrampolineFromCode(Method* called, Method** sp, Thread* thread,
-                                                     Runtime::TrampolineType type) {
+                                                     Runtime::TrampolineType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
 #if defined(__arm__)
   // On entry the stack pointed by sp is:
   // | argN       |  |
@@ -82,7 +83,7 @@
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
   // Start new JNI local reference state
   JNIEnvExt* env = thread->GetJniEnv();
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccessUnchecked soa(env);
   ScopedJniEnvLocalRefState env_state(env);
 
   // Compute details about the called method (avoid GCs)
@@ -147,7 +148,7 @@
       // If we thought we had fewer than 3 arguments in registers, account for the receiver
       args_in_regs++;
     }
-    ts.AddLocalReference<jobject>(obj);
+    soa.AddLocalReference<jobject>(obj);
   }
   size_t shorty_index = 1;  // skip return value
   // Iterate while arguments and arguments in registers (less 1 from cur_arg which is offset to skip
@@ -157,7 +158,7 @@
     shorty_index++;
     if (c == 'L') {
       Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
-      ts.AddLocalReference<jobject>(obj);
+      soa.AddLocalReference<jobject>(obj);
     }
     cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
   }
@@ -168,7 +169,7 @@
     shorty_index++;
     if (c == 'L') {
       Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
-      ts.AddLocalReference<jobject>(obj);
+      soa.AddLocalReference<jobject>(obj);
     }
     cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
   }
@@ -308,7 +309,8 @@
 
 #if !defined(ART_USE_LLVM_COMPILER)
 // Called by the AbstractMethodError. Called by stub code.
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp) {
+extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
                              "abstract method \"%s\"", PrettyMethod(method).c_str());
diff --git a/src/oat/runtime/support_thread.cc b/src/oat/runtime/support_thread.cc
index 6cd595b..32284bb 100644
--- a/src/oat/runtime/support_thread.cc
+++ b/src/oat/runtime/support_thread.cc
@@ -20,15 +20,18 @@
 
 namespace art {
 
-void CheckSuspendFromCode(Thread* thread) {
-  // Called when thread->suspend_count_ != 0
-  Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
+void CheckSuspendFromCode(Thread* thread)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  // Called when thread->suspend_count_ != 0 on JNI return. JNI method acts as callee-save frame.
+  thread->VerifyStack();
+  thread->FullSuspendCheck();
 }
 
-extern "C" void artTestSuspendFromCode(Thread* thread, Method** sp) {
+extern "C" void artTestSuspendFromCode(Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Called when suspend count check value is 0 and thread->suspend_count_ != 0
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
-  Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
+  thread->FullSuspendCheck();
 }
 
 }  // namespace art
diff --git a/src/oat/runtime/support_throw.cc b/src/oat/runtime/support_throw.cc
index 31cf7d9..4fa2387 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -23,13 +23,15 @@
 namespace art {
 
 // Deliver an exception that's pending on thread helping set up a callee save frame on the way.
-extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, Method** sp) {
+extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   thread->DeliverException();
 }
 
 // Called by generated call to throw an exception.
-extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread, Method** sp) {
+extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   /*
    * exception may be NULL, in which case this routine should
    * throw NPE.  NOTE: this is a convenience for generated code,
@@ -47,7 +49,8 @@
 }
 
 // Called by generated call to throw a NPE exception.
-extern "C" void artThrowNullPointerExceptionFromCode(Thread* self, Method** sp) {
+extern "C" void artThrowNullPointerExceptionFromCode(Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   uint32_t dex_pc;
   Method* throw_method = self->GetCurrentMethod(&dex_pc);
@@ -56,21 +59,24 @@
 }
 
 // Called by generated call to throw an arithmetic divide by zero exception.
-extern "C" void artThrowDivZeroFromCode(Thread* thread, Method** sp) {
+extern "C" void artThrowDivZeroFromCode(Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   thread->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
   thread->DeliverException();
 }
 
 // Called by generated call to throw an array index out of bounds exception.
-extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread, Method** sp) {
+extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   thread->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
                              "length=%d; index=%d", limit, index);
   thread->DeliverException();
 }
 
-extern "C" void artThrowStackOverflowFromCode(Thread* thread, Method** sp) {
+extern "C" void artThrowStackOverflowFromCode(Thread* thread, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
   // Remove extra entry pushed onto second stack during method tracing.
   if (Runtime::Current()->IsMethodTracingActive()) {
@@ -83,7 +89,8 @@
   thread->DeliverException();
 }
 
-extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp) {
+extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   Method* method = self->GetCurrentMethod();
   self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
@@ -91,7 +98,9 @@
   self->DeliverException();
 }
 
-extern "C" void artThrowVerificationErrorFromCode(int32_t kind, int32_t ref, Thread* self, Method** sp) {
+extern "C" void artThrowVerificationErrorFromCode(int32_t kind, int32_t ref, Thread* self,
+                                                  Method** sp)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
   Method* method = self->GetCurrentMethod();
   ThrowVerificationError(self, method, kind, ref);
diff --git a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
index a28a898..e52569d 100644
--- a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -59,8 +59,17 @@
 extern "C" void art_handle_fill_data_from_code(void*, void*);
 
 // JNI entrypoints.
-extern Object* DecodeJObjectInThread(Thread* thread, jobject obj);
 extern void* FindNativeMethod(Thread* thread);
+extern uint32_t JniMethodStart(Thread* self);
+extern uint32_t JniMethodStartSynchronized(jobject to_lock, Thread* self);
+extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self);
+extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie, jobject locked,
+                                     Thread* self);
+extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+                                         Thread* self);
+extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
+                                                     uint32_t saved_local_ref_cookie,
+                                                     jobject locked, Thread* self);
 
 // Lock entrypoints.
 extern "C" void art_lock_object_from_code(void*);
@@ -153,8 +162,13 @@
   points->pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
 
   // JNI
-  points->pDecodeJObjectInThread = DecodeJObjectInThread;
   points->pFindNativeMethod = FindNativeMethod;
+  points->pJniMethodStart = JniMethodStart;
+  points->pJniMethodStartSynchronized = JniMethodStartSynchronized;
+  points->pJniMethodEnd = JniMethodEnd;
+  points->pJniMethodEndSynchronized = JniMethodEndSynchronized;
+  points->pJniMethodEndWithReference = JniMethodEndWithReference;
+  points->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
   points->pLockObjectFromCode = art_lock_object_from_code;
diff --git a/src/oat/runtime/x86/stub_x86.cc b/src/oat/runtime/x86/stub_x86.cc
index a9db314..74e0f39 100644
--- a/src/oat/runtime/x86/stub_x86.cc
+++ b/src/oat/runtime/x86/stub_x86.cc
@@ -16,6 +16,7 @@
 
 #include "jni_internal.h"
 #include "oat/runtime/oat_support_entrypoints.h"
+#include "oat/runtime/stub.h"
 #include "oat/utils/x86/assembler_x86.h"
 #include "object.h"
 #include "stack_indirect_reference_table.h"
diff --git a/src/oat/utils/arm/assembler_arm.cc b/src/oat/utils/arm/assembler_arm.cc
index 55b6187..de665dd 100644
--- a/src/oat/utils/arm/assembler_arm.cc
+++ b/src/oat/utils/arm/assembler_arm.cc
@@ -1440,10 +1440,9 @@
                               const std::vector<ManagedRegister>& callee_save_regs,
                               const std::vector<ManagedRegister>& entry_spills) {
   CHECK_ALIGNED(frame_size, kStackAlignment);
-  DCHECK_EQ(entry_spills.size(), 0u);
   CHECK_EQ(R0, method_reg.AsArm().AsCoreRegister());
 
-  // Push callee saves and link register
+  // Push callee saves and link register.
   RegList push_list = 1 << LR;
   size_t pushed_values = 1;
   for (size_t i = 0; i < callee_save_regs.size(); i++) {
@@ -1453,13 +1452,19 @@
   }
   PushList(push_list);
 
-  // Increase frame to required size
+  // Increase frame to required size.
   CHECK_GT(frame_size, pushed_values * kPointerSize);  // Must be at least space to push Method*
   size_t adjust = frame_size - (pushed_values * kPointerSize);
   IncreaseFrameSize(adjust);
 
-  // Write out Method*
+  // Write out Method*.
   StoreToOffset(kStoreWord, R0, SP, 0);
+
+  // Write out entry spills.
+  for (size_t i = 0; i < entry_spills.size(); ++i) {
+    Register reg = entry_spills.at(i).AsArm().AsCoreRegister();
+    StoreToOffset(kStoreWord, reg, SP, frame_size + kPointerSize + (i * kPointerSize));
+  }
 }
 
 void ArmAssembler::RemoveFrame(size_t frame_size,
@@ -1891,9 +1896,9 @@
 #undef __
 }
 
-void ArmAssembler::ExceptionPoll(ManagedRegister mscratch) {
+void ArmAssembler::ExceptionPoll(ManagedRegister mscratch, size_t stack_adjust) {
   ArmManagedRegister scratch = mscratch.AsArm();
-  ArmExceptionSlowPath* slow = new ArmExceptionSlowPath(scratch);
+  ArmExceptionSlowPath* slow = new ArmExceptionSlowPath(scratch, stack_adjust);
   buffer_.EnqueueSlowPath(slow);
   LoadFromOffset(kLoadWord, scratch.AsCoreRegister(),
                  TR, Thread::ExceptionOffset().Int32Value());
@@ -1905,7 +1910,9 @@
   ArmAssembler* sp_asm = down_cast<ArmAssembler*>(sasm);
 #define __ sp_asm->
   __ Bind(&entry_);
-
+  if (stack_adjust_ != 0) {  // Fix up the frame.
+    __ DecreaseFrameSize(stack_adjust_);
+  }
   // Pass exception object as argument
   // Don't care about preserving R0 as this call won't return
   __ mov(R0, ShifterOperand(scratch_.AsCoreRegister()));
diff --git a/src/oat/utils/arm/assembler_arm.h b/src/oat/utils/arm/assembler_arm.h
index edfaf30..2410bac 100644
--- a/src/oat/utils/arm/assembler_arm.h
+++ b/src/oat/utils/arm/assembler_arm.h
@@ -564,7 +564,7 @@
 
   // Generate code to check if Thread::Current()->exception_ is non-null
   // and branch to a ExceptionSlowPath if it is.
-  virtual void ExceptionPoll(ManagedRegister scratch);
+  virtual void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust);
 
  private:
   void EmitType01(Condition cond,
@@ -650,10 +650,13 @@
 // Slowpath entered when Thread::Current()->_exception is non-null
 class ArmExceptionSlowPath : public SlowPath {
  public:
-  explicit ArmExceptionSlowPath(ArmManagedRegister scratch) : scratch_(scratch) {}
+  explicit ArmExceptionSlowPath(ArmManagedRegister scratch, size_t stack_adjust)
+      : scratch_(scratch), stack_adjust_(stack_adjust) {
+  }
   virtual void Emit(Assembler *sp_asm);
  private:
   const ArmManagedRegister scratch_;
+  const size_t stack_adjust_;
 };
 
 // Slowpath entered when Thread::Current()->_suspend_count is non-zero
diff --git a/src/oat/utils/assembler.h b/src/oat/utils/assembler.h
index dabd321..68108e7 100644
--- a/src/oat/utils/assembler.h
+++ b/src/oat/utils/assembler.h
@@ -446,7 +446,7 @@
 
   // Generate code to check if Thread::Current()->exception_ is non-null
   // and branch to a ExceptionSlowPath if it is.
-  virtual void ExceptionPoll(ManagedRegister scratch) = 0;
+  virtual void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) = 0;
 
   virtual ~Assembler() {}
 
diff --git a/src/oat/utils/x86/assembler_x86.cc b/src/oat/utils/x86/assembler_x86.cc
index b7f0c1f..78f2b57 100644
--- a/src/oat/utils/x86/assembler_x86.cc
+++ b/src/oat/utils/x86/assembler_x86.cc
@@ -1862,8 +1862,8 @@
 #undef __
 }
 
-void X86Assembler::ExceptionPoll(ManagedRegister /*scratch*/) {
-  X86ExceptionSlowPath* slow = new X86ExceptionSlowPath();
+void X86Assembler::ExceptionPoll(ManagedRegister /*scratch*/, size_t stack_adjust) {
+  X86ExceptionSlowPath* slow = new X86ExceptionSlowPath(stack_adjust);
   buffer_.EnqueueSlowPath(slow);
   fs()->cmpl(Address::Absolute(Thread::ExceptionOffset()), Immediate(0));
   j(kNotEqual, slow->Entry());
@@ -1874,6 +1874,9 @@
 #define __ sp_asm->
   __ Bind(&entry_);
   // Note: the return value is dead
+  if (stack_adjust_ != 0) {  // Fix up the frame.
+    __ DecreaseFrameSize(stack_adjust_);
+  }
   // Pass exception as argument in EAX
   __ fs()->movl(EAX, Address::Absolute(Thread::ExceptionOffset()));
   __ fs()->call(Address::Absolute(ENTRYPOINT_OFFSET(pDeliverException)));
diff --git a/src/oat/utils/x86/assembler_x86.h b/src/oat/utils/x86/assembler_x86.h
index c8edf44..7291211 100644
--- a/src/oat/utils/x86/assembler_x86.h
+++ b/src/oat/utils/x86/assembler_x86.h
@@ -598,7 +598,7 @@
 
   // Generate code to check if Thread::Current()->exception_ is non-null
   // and branch to a ExceptionSlowPath if it is.
-  virtual void ExceptionPoll(ManagedRegister scratch);
+  virtual void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust);
 
  private:
   inline void EmitUint8(uint8_t value);
@@ -650,8 +650,10 @@
 // Slowpath entered when Thread::Current()->_exception is non-null
 class X86ExceptionSlowPath : public SlowPath {
  public:
-  X86ExceptionSlowPath() {}
+  X86ExceptionSlowPath(size_t stack_adjust) : stack_adjust_(stack_adjust) {}
   virtual void Emit(Assembler *sp_asm);
+ private:
+  const size_t stack_adjust_;
 };
 
 // Slowpath entered when Thread::Current()->_suspend_count is non-zero
diff --git a/src/oat_compilation_unit.h b/src/oat_compilation_unit.h
index 41c1847..97815ac 100644
--- a/src/oat_compilation_unit.h
+++ b/src/oat_compilation_unit.h
@@ -30,23 +30,19 @@
 
 class OatCompilationUnit {
  public:
-  OatCompilationUnit(ClassLoader* class_loader, ClassLinker* class_linker,
-                     const DexFile& dex_file, DexCache& dex_cache,
-                     const DexFile::CodeItem* code_item,
-                     uint32_t method_idx, uint32_t access_flags)
-      : class_loader_(class_loader), class_linker_(class_linker),
-        dex_file_(&dex_file), dex_cache_(&dex_cache), code_item_(code_item),
-        method_idx_(method_idx), access_flags_(access_flags) {
+  OatCompilationUnit(jobject class_loader, ClassLinker* class_linker, const DexFile& dex_file,
+                     const DexFile::CodeItem* code_item, uint32_t method_idx, uint32_t access_flags)
+      : class_loader_(class_loader), class_linker_(class_linker), dex_file_(&dex_file),
+        code_item_(code_item), method_idx_(method_idx), access_flags_(access_flags) {
   }
 
   OatCompilationUnit* GetCallee(uint32_t callee_method_idx,
                                 uint32_t callee_access_flags) {
-    return new OatCompilationUnit(class_loader_, class_linker_, *dex_file_,
-                                  *dex_cache_, NULL, callee_method_idx,
-                                  callee_access_flags);
+    return new OatCompilationUnit(class_loader_, class_linker_, *dex_file_, NULL,
+                                  callee_method_idx, callee_access_flags);
   }
 
-  ClassLoader* GetClassLoader() const {
+  jobject GetClassLoader() const {
     return class_loader_;
   }
 
@@ -58,10 +54,6 @@
     return dex_file_;
   }
 
-  DexCache* GetDexCache() const {
-    return dex_cache_;
-  }
-
   uint32_t GetDexMethodIndex() const {
     return method_idx_;
   }
@@ -85,15 +77,14 @@
   }
 
  public:
-  ClassLoader* class_loader_;
-  ClassLinker* class_linker_;
+  jobject class_loader_;
+  ClassLinker* const class_linker_;
 
-  const DexFile* dex_file_;
-  DexCache* dex_cache_;
+  const DexFile* const dex_file_;
 
-  const DexFile::CodeItem* code_item_;
-  uint32_t method_idx_;
-  uint32_t access_flags_;
+  const DexFile::CodeItem* const code_item_;
+  const uint32_t method_idx_;
+  const uint32_t access_flags_;
 };
 
 } // namespace art
diff --git a/src/oat_test.cc b/src/oat_test.cc
index dae61bb..288854b 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -25,7 +25,8 @@
  protected:
   void CheckMethod(Method* method,
                    const OatFile::OatMethod& oat_method,
-                   const DexFile* dex_file) {
+                   const DexFile* dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const CompiledMethod* compiled_method =
         compiler_->GetCompiledMethod(Compiler::MethodReference(dex_file,
                                                                method->GetDexMethodIndex()));
@@ -62,15 +63,16 @@
   const bool compile = false;  // DISABLED_ due to the time to compile libcore
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
 
-  SirtRef<ClassLoader> class_loader(NULL);
+  jobject class_loader = NULL;
   if (compile) {
     compiler_.reset(new Compiler(kThumb2, false, 2, false, NULL, true, true));
-    compiler_->CompileAll(class_loader.get(), class_linker->GetBootClassPath());
+    compiler_->CompileAll(class_loader, class_linker->GetBootClassPath());
   }
 
+  ScopedObjectAccess soa(Thread::Current());
   ScratchFile tmp;
   bool success = OatWriter::Create(tmp.GetFile(),
-                                   class_loader.get(),
+                                   class_loader,
                                    class_linker->GetBootClassPath(),
                                    42U,
                                    "lue.art",
@@ -78,7 +80,7 @@
   ASSERT_TRUE(success);
 
   if (compile) {  // OatWriter strips the code, regenerate to compare
-    compiler_->CompileAll(class_loader.get(), class_linker->GetBootClassPath());
+    compiler_->CompileAll(class_loader, class_linker->GetBootClassPath());
   }
   UniquePtr<OatFile> oat_file(OatFile::Open(tmp.GetFilename(),
                                             tmp.GetFilename(),
@@ -105,7 +107,7 @@
 
     UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(i));
 
-    Class* klass = class_linker->FindClass(descriptor, class_loader.get());
+    Class* klass = class_linker->FindClass(descriptor, NULL);
 
     size_t method_index = 0;
     for (size_t i = 0; i < klass->NumDirectMethods(); i++, method_index++) {
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 013a561..0546f2b 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -23,13 +23,14 @@
 #include "file.h"
 #include "os.h"
 #include "safe_map.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "stl_util.h"
 
 namespace art {
 
 bool OatWriter::Create(File* file,
-                       ClassLoader* class_loader,
+                       jobject class_loader,
                        const std::vector<const DexFile*>& dex_files,
                        uint32_t image_file_location_checksum,
                        const std::string& image_file_location,
@@ -45,7 +46,7 @@
 OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
                      uint32_t image_file_location_checksum,
                      const std::string& image_file_location,
-                     ClassLoader* class_loader,
+                     jobject class_loader,
                      const Compiler& compiler) {
   compiler_ = &compiler;
   class_loader_ = class_loader;
@@ -380,8 +381,10 @@
   if (compiler_->IsImage()) {
     ClassLinker* linker = Runtime::Current()->GetClassLinker();
     DexCache* dex_cache = linker->FindDexCache(*dex_file);
-    Method* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader_,
-                                           is_direct);
+    // Unchecked as we hold mutator_lock_ on entry.
+    ScopedObjectAccessUnchecked soa(Thread::Current());
+    Method* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
+                                           soa.Decode<ClassLoader*>(class_loader_), is_direct);
     CHECK(method != NULL);
     method->SetFrameSizeInBytes(frame_size_in_bytes);
     method->SetCoreSpillMask(core_spill_mask);
diff --git a/src/oat_writer.h b/src/oat_writer.h
index b748dbc..60a79a2 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -64,18 +64,19 @@
  public:
   // Write an oat file. Returns true on success, false on failure.
   static bool Create(File* file,
-                     ClassLoader* class_loader,
+                     jobject class_loader,
                      const std::vector<const DexFile*>& dex_files,
                      uint32_t image_file_location_checksum,
                      const std::string& image_file_location,
-                     const Compiler& compiler);
+                     const Compiler& compiler)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   OatWriter(const std::vector<const DexFile*>& dex_files,
             uint32_t image_file_location_checksum,
             const std::string& image_file_location,
-            ClassLoader* class_loader,
-            const Compiler& compiler);
+            jobject class_loader,
+            const Compiler& compiler) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   ~OatWriter();
 
   size_t InitOatHeader();
@@ -83,17 +84,21 @@
   size_t InitDexFiles(size_t offset);
   size_t InitOatClasses(size_t offset);
   size_t InitOatCode(size_t offset);
-  size_t InitOatCodeDexFiles(size_t offset);
+  size_t InitOatCodeDexFiles(size_t offset)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   size_t InitOatCodeDexFile(size_t offset,
                             size_t& oat_class_index,
-                            const DexFile& dex_file);
+                            const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   size_t InitOatCodeClassDef(size_t offset,
                              size_t oat_class_index, size_t class_def_index,
                              const DexFile& dex_file,
-                             const DexFile::ClassDef& class_def);
+                             const DexFile::ClassDef& class_def)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   size_t InitOatCodeMethod(size_t offset, size_t oat_class_index, size_t class_def_index,
                            size_t class_def_method_index, bool is_native, bool is_static,
-                           bool is_direct, uint32_t method_idx, const DexFile*);
+                           bool is_direct, uint32_t method_idx, const DexFile*)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool Write(File* file);
   bool WriteTables(File* file);
@@ -146,7 +151,7 @@
   const Compiler* compiler_;
 
   // TODO: remove the ClassLoader when the code storage moves out of Method
-  ClassLoader* class_loader_;
+  jobject class_loader_;
 
   // note OatFile does not take ownership of the DexFiles
   const std::vector<const DexFile*>* dex_files_;
diff --git a/src/oatdump.cc b/src/oatdump.cc
index b1aa47e..2fc728e 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -32,6 +32,7 @@
 #include "os.h"
 #include "runtime.h"
 #include "safe_map.h"
+#include "scoped_thread_state_change.h"
 #include "space.h"
 #include "stringpiece.h"
 #include "verifier/gc_map.h"
@@ -155,7 +156,7 @@
     return oat_file_.GetOatHeader().GetInstructionSet();
   }
 
-  const void* GetOatCode(Method* m) {
+  const void* GetOatCode(Method* m) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     MethodHelper mh(m);
     for (size_t i = 0; i < oat_dex_files_.size(); i++) {
       const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
@@ -486,7 +487,7 @@
       : os_(os), image_filename_(image_filename), host_prefix_(host_prefix),
         image_space_(image_space), image_header_(image_header) {}
 
-  void Dump() {
+  void Dump() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     os_ << "MAGIC:\n";
     os_ << image_header_.GetMagic() << "\n\n";
 
@@ -578,7 +579,8 @@
   }
 
  private:
-  static void PrettyObjectValue(std::string& summary, Class* type, Object* value) {
+  static void PrettyObjectValue(std::string& summary, Class* type, Object* value)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(type != NULL);
     if (value == NULL) {
       StringAppendF(&summary, "null   %s\n", PrettyDescriptor(type).c_str());
@@ -599,7 +601,8 @@
     }
   }
 
-  static void PrintField(std::string& summary, Field* field, Object* obj) {
+  static void PrintField(std::string& summary, Field* field, Object* obj)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     FieldHelper fh(field);
     Class* type = fh.GetType();
     StringAppendF(&summary, "\t%s: ", fh.GetName());
@@ -617,7 +620,8 @@
     }
   }
 
-  static void DumpFields(std::string& summary, Object* obj, Class* klass) {
+  static void DumpFields(std::string& summary, Object* obj, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* super = klass->GetSuperClass();
     if (super != NULL) {
       DumpFields(summary, obj, super);
@@ -635,7 +639,8 @@
     return image_space_.Contains(object);
   }
 
-  const void* GetOatCodeBegin(Method* m) {
+  const void* GetOatCodeBegin(Method* m)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Runtime* runtime = Runtime::Current();
     const void* code = m->GetCode();
     if (code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
@@ -647,7 +652,8 @@
     return code;
   }
 
-  uint32_t GetOatCodeSize(Method* m) {
+  uint32_t GetOatCodeSize(Method* m)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetOatCodeBegin(m));
     if (oat_code_begin == NULL) {
       return 0;
@@ -655,7 +661,8 @@
     return oat_code_begin[-1];
   }
 
-  const void* GetOatCodeEnd(Method* m) {
+  const void* GetOatCodeEnd(Method* m)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetOatCodeBegin(m));
     if (oat_code_begin == NULL) {
       return NULL;
@@ -663,7 +670,8 @@
     return oat_code_begin + GetOatCodeSize(m);
   }
 
-  static void Callback(Object* obj, void* arg) {
+  static void Callback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(obj != NULL);
     DCHECK(arg != NULL);
     ImageDumper* state = reinterpret_cast<ImageDumper*>(arg);
@@ -921,7 +929,8 @@
       method_outlier.push_back(method);
     }
 
-    void DumpOutliers(std::ostream& os) {
+    void DumpOutliers(std::ostream& os)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
       size_t sum_of_sizes = 0;
       size_t sum_of_sizes_squared = 0;
       size_t sum_of_expansion = 0;
@@ -1021,7 +1030,7 @@
       os << "\n" << std::flush;
     }
 
-    void Dump(std::ostream& os) {
+    void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
       os << "\tart_file_bytes = " << PrettySize(file_bytes) << "\n\n"
          << "\tart_file_bytes = header_bytes + object_bytes + alignment_bytes\n"
          << StringPrintf("\theader_bytes    =  %8zd (%2.0f%% of art file bytes)\n"
@@ -1197,11 +1206,15 @@
     options.push_back(std::make_pair("host-prefix", host_prefix->c_str()));
   }
 
-  UniquePtr<Runtime> runtime(Runtime::Create(options, false));
-  if (runtime.get() == NULL) {
+  if (!Runtime::Create(options, false)) {
     fprintf(stderr, "Failed to create runtime\n");
     return EXIT_FAILURE;
   }
+  UniquePtr<Runtime> runtime(Runtime::Current());
+  // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
+  // give it away now and then switch to a more managable ScopedObjectAccess.
+  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
+  ScopedObjectAccess soa(Thread::Current());
 
   Heap* heap = Runtime::Current()->GetHeap();
   ImageSpace* image_space = heap->GetImageSpace();
diff --git a/src/object.cc b/src/object.cc
index ecaef3b..dd984fc 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -425,7 +425,8 @@
   return result;
 }
 
-static const void* GetOatCode(const Method* m) {
+static const void* GetOatCode(const Method* m)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Runtime* runtime = Runtime::Current();
   const void* code = m->GetCode();
   // Peel off any method tracing trampoline.
@@ -513,10 +514,13 @@
 }
 
 void Method::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const {
-  // Push a transition back into managed code onto the linked list in thread.
-  CHECK_EQ(kRunnable, self->GetState());
-  self->AssertThreadSuspensionIsAllowable();
+  if (kIsDebugBuild) {
+    self->AssertThreadSuspensionIsAllowable();
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(kRunnable, self->GetState());
+  }
 
+  // Push a transition back into managed code onto the linked list in thread.
   ManagedStack fragment;
   self->PushManagedStackFragment(&fragment);
 
@@ -1219,6 +1223,7 @@
 }
 
 Array* Array::Alloc(Class* array_class, int32_t component_count) {
+  DCHECK(array_class->IsArrayClass());
   return Alloc(array_class, component_count, array_class->GetComponentSize());
 }
 
diff --git a/src/object.h b/src/object.h
index 0fc6acc..03ed132 100644
--- a/src/object.h
+++ b/src/object.h
@@ -209,35 +209,48 @@
 
   void SetClass(Class* new_klass);
 
-  bool InstanceOf(const Class* klass) const;
+  bool InstanceOf(const Class* klass) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  size_t SizeOf() const;
+  size_t SizeOf() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Object* Clone();
+  Object* Clone() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+  int32_t IdentityHashCode() const {
+  #ifdef MOVING_GARBAGE_COLLECTOR
+    // TODO: we'll need to use the Object's internal concept of identity
+      UNIMPLEMENTED(FATAL);
+  #endif
+    return reinterpret_cast<int32_t>(this);
+  }
 
   static MemberOffset MonitorOffset() {
     return OFFSET_OF_OBJECT_MEMBER(Object, monitor_);
   }
 
   volatile int32_t* GetRawLockWordAddress() {
-    byte* raw_addr = reinterpret_cast<byte*>(this) + OFFSET_OF_OBJECT_MEMBER(Object, monitor_).Int32Value();
+    byte* raw_addr = reinterpret_cast<byte*>(this) +
+        OFFSET_OF_OBJECT_MEMBER(Object, monitor_).Int32Value();
     int32_t* word_addr = reinterpret_cast<int32_t*>(raw_addr);
     return const_cast<volatile int32_t*>(word_addr);
   }
 
   uint32_t GetThinLockId();
 
-  void MonitorEnter(Thread* thread);
+  void MonitorEnter(Thread* thread) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      EXCLUSIVE_LOCK_FUNCTION(monitor_lock_);
 
-  bool MonitorExit(Thread* thread);
+  bool MonitorExit(Thread* thread) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      UNLOCK_FUNCTION(monitor_lock_);
 
-  void Notify();
+  void Notify() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void NotifyAll();
+  void NotifyAll() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Wait(int64_t timeout);
+  void Wait(int64_t timeout) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Wait(int64_t timeout, int32_t nanos);
+  void Wait(int64_t timeout, int32_t nanos)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsClass() const;
 
@@ -285,14 +298,14 @@
     return down_cast<const Method*>(this);
   }
 
-  bool IsField() const;
+  bool IsField() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Field* AsField() {
+  Field* AsField() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(IsField());
     return down_cast<Field*>(this);
   }
 
-  const Field* AsField() const {
+  const Field* AsField() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(IsField());
     return down_cast<const Field*>(this);
   }
@@ -403,16 +416,6 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
 };
 
-struct ObjectIdentityHash {
-  size_t operator()(const Object* const& obj) const {
-#ifdef MOVING_GARBAGE_COLLECTOR
-  // TODO: we'll need to use the Object's internal concept of identity
-    UNIMPLEMENTED(FATAL);
-#endif
-    return reinterpret_cast<size_t>(obj);
-  }
-};
-
 // C++ mirror of java.lang.reflect.Field
 class MANAGED Field : public Object {
  public:
@@ -458,32 +461,56 @@
   void SetOffset(MemberOffset num_bytes);
 
   // field access, null object for static fields
-  bool GetBoolean(const Object* object) const;
-  void SetBoolean(Object* object, bool z) const;
-  int8_t GetByte(const Object* object) const;
-  void SetByte(Object* object, int8_t b) const;
-  uint16_t GetChar(const Object* object) const;
-  void SetChar(Object* object, uint16_t c) const;
-  int16_t GetShort(const Object* object) const;
-  void SetShort(Object* object, int16_t s) const;
-  int32_t GetInt(const Object* object) const;
-  void SetInt(Object* object, int32_t i) const;
-  int64_t GetLong(const Object* object) const;
-  void SetLong(Object* object, int64_t j) const;
-  float GetFloat(const Object* object) const;
-  void SetFloat(Object* object, float f) const;
-  double GetDouble(const Object* object) const;
-  void SetDouble(Object* object, double d) const;
-  Object* GetObject(const Object* object) const;
-  void SetObject(Object* object, const Object* l) const;
+  bool GetBoolean(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetBoolean(Object* object, bool z) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  int8_t GetByte(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetByte(Object* object, int8_t b) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  uint16_t GetChar(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetChar(Object* object, uint16_t c) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  int16_t GetShort(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetShort(Object* object, int16_t s) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  int32_t GetInt(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetInt(Object* object, int32_t i) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  int64_t GetLong(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetLong(Object* object, int64_t j) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  float GetFloat(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetFloat(Object* object, float f) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  double GetDouble(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetDouble(Object* object, double d) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Object* GetObject(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetObject(Object* object, const Object* l) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // raw field accesses
-  uint32_t Get32(const Object* object) const;
-  void Set32(Object* object, uint32_t new_value) const;
-  uint64_t Get64(const Object* object) const;
-  void Set64(Object* object, uint64_t new_value) const;
-  Object* GetObj(const Object* object) const;
-  void SetObj(Object* object, const Object* new_value) const;
+  uint32_t Get32(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void Set32(Object* object, uint32_t new_value) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  uint64_t Get64(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void Set64(Object* object, uint64_t new_value) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Object* GetObj(const Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void SetObj(Object* object, const Object* new_value) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static Class* GetJavaLangReflectField() {
     DCHECK(java_lang_reflect_Field_ != NULL);
@@ -658,9 +685,10 @@
   void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value);
 
   // Find the method that this method overrides
-  Method* FindOverriddenMethod() const;
+  Method* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const;
+  void Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   const void* GetCode() const {
     return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), false);
@@ -670,7 +698,7 @@
     SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), code, false);
   }
 
-  uint32_t GetCodeSize() const {
+  uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
     uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
     if (code == 0) {
@@ -681,7 +709,8 @@
     return reinterpret_cast<uint32_t*>(code)[-1];
   }
 
-  bool IsWithinCode(uintptr_t pc) const {
+  bool IsWithinCode(uintptr_t pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
     if (code == 0) {
       return pc == 0;
@@ -689,7 +718,8 @@
     return (code <= pc && pc < code + GetCodeSize());
   }
 
-  void AssertPcIsWithinCode(uintptr_t pc) const;
+  void AssertPcIsWithinCode(uintptr_t pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   uint32_t GetOatCodeOffset() const {
     DCHECK(!Runtime::Current()->IsStarted());
@@ -813,9 +843,10 @@
 
   bool IsRegistered() const;
 
-  void RegisterNative(Thread* self, const void* native_method);
+  void RegisterNative(Thread* self, const void* native_method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void UnregisterNative(Thread* self);
+  void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static MemberOffset NativeMethodOffset() {
     return OFFSET_OF_OBJECT_MEMBER(Method, native_method_);
@@ -915,14 +946,17 @@
 
   // Converts a native PC to a dex PC.  TODO: this is a no-op
   // until we associate a PC mapping table with each method.
-  uint32_t ToDexPC(const uintptr_t pc) const;
+  uint32_t ToDexPC(const uintptr_t pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Converts a dex PC to a native PC.  TODO: this is a no-op
   // until we associate a PC mapping table with each method.
-  uintptr_t ToNativePC(const uint32_t dex_pc) const;
+  uintptr_t ToNativePC(const uint32_t dex_pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Find the catch block for the given exception type and dex_pc
-  uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc) const;
+  uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static void SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method);
 
@@ -1012,9 +1046,11 @@
  public:
   // A convenience for code that doesn't know the component size,
   // and doesn't want to have to work it out itself.
-  static Array* Alloc(Class* array_class, int32_t component_count);
+  static Array* Alloc(Class* array_class, int32_t component_count)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static Array* Alloc(Class* array_class, int32_t component_count, size_t component_size);
+  static Array* Alloc(Class* array_class, int32_t component_count, size_t component_size)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   size_t SizeOf() const;
 
@@ -1051,7 +1087,8 @@
   }
 
  protected:
-  bool IsValidIndex(int32_t index) const {
+  bool IsValidIndex(int32_t index) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (UNLIKELY(index < 0 || index >= length_)) {
       return ThrowArrayIndexOutOfBoundsException(index);
     }
@@ -1059,8 +1096,10 @@
   }
 
  protected:
-  bool ThrowArrayIndexOutOfBoundsException(int32_t index) const;
-  bool ThrowArrayStoreException(Object* object) const;
+  bool ThrowArrayIndexOutOfBoundsException(int32_t index) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool ThrowArrayStoreException(Object* object) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   // The number of array elements.
@@ -1074,23 +1113,27 @@
 template<class T>
 class MANAGED ObjectArray : public Array {
  public:
-  static ObjectArray<T>* Alloc(Class* object_array_class, int32_t length);
+  static ObjectArray<T>* Alloc(Class* object_array_class, int32_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  T* Get(int32_t i) const;
+  T* Get(int32_t i) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void Set(int32_t i, T* object);
+  void Set(int32_t i, T* object) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Set element without bound and element type checks, to be used in limited
   // circumstances, such as during boot image writing
-  void SetWithoutChecks(int32_t i, T* object);
+  void SetWithoutChecks(int32_t i, T* object)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  T* GetWithoutChecks(int32_t i) const;
+  T* GetWithoutChecks(int32_t i) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static void Copy(const ObjectArray<T>* src, int src_pos,
                    ObjectArray<T>* dst, int dst_pos,
-                   size_t length);
+                   size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  ObjectArray<T>* CopyOf(int32_t new_length);
+  ObjectArray<T>* CopyOf(int32_t new_length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectArray);
@@ -1181,7 +1224,7 @@
     return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
   }
 
-  void SetStatus(Status new_status);
+  void SetStatus(Status new_status) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Returns true if the class has failed to link.
   bool IsErroneous() const {
@@ -1291,7 +1334,8 @@
 
   String* GetName() const; // Returns the cached name
   void SetName(String* name);  // Sets the cached name
-  String* ComputeName();  // Computes the name, then sets the cached value
+  String* ComputeName()  // Computes the name, then sets the cached value
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsProxyClass() const {
     // Read access flags without using getter as whether something is a proxy can be check in
@@ -1370,7 +1414,7 @@
 
   bool IsStringClass() const;
 
-  bool IsThrowableClass() const;
+  bool IsThrowableClass() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Class* GetComponentType() const {
     return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), false);
@@ -1394,7 +1438,7 @@
   }
 
   // Creates a raw object instance but does not invoke the default constructor.
-  Object* AllocObject();
+  Object* AllocObject() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsVariableSize() const {
     // Classes and arrays vary in size, and so the object_size_ field cannot
@@ -1412,9 +1456,10 @@
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
   }
 
-  void SetClassSize(size_t new_class_size);
+  void SetClassSize(size_t new_class_size)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  size_t GetObjectSize() const {
+  size_t GetObjectSize() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(!IsVariableSize()) << " class=" << PrettyTypeOf(this);
     DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), false);
@@ -1429,19 +1474,21 @@
   }
 
   // Returns true if this class is in the same packages as that class.
-  bool IsInSamePackage(const Class* that) const;
+  bool IsInSamePackage(const Class* that) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static bool IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2);
 
   // Returns true if this class can access that class.
-  bool CanAccess(Class* that) const {
+  bool CanAccess(Class* that) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return that->IsPublic() || this->IsInSamePackage(that);
   }
 
   // Can this class access a member in the provided class with the provided member access flags?
   // Note that access to the class isn't checked in case the declaring class is protected and the
   // method has been exposed by a public sub-class
-  bool CanAccessMember(Class* access_to, uint32_t member_flags) const {
+  bool CanAccessMember(Class* access_to, uint32_t member_flags) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // Classes can access all of their own members
     if (this == access_to) {
       return true;
@@ -1464,14 +1511,16 @@
     return this->IsInSamePackage(access_to);
   }
 
-  bool IsSubClass(const Class* klass) const;
+  bool IsSubClass(const Class* klass) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Can src be assigned to this class? For example, String can be assigned to Object (by an
   // upcast), however, an Object cannot be assigned to a String as a potentially exception throwing
   // downcast would be necessary. Similarly for interfaces, a class that implements (or an interface
   // that extends) another can be assigned to its parent, but not vice-versa. All Classes may assign
   // to themselves. Classes for primitive types may not assign to each other.
-  bool IsAssignableFrom(const Class* src) const {
+  bool IsAssignableFrom(const Class* src) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(src != NULL);
     if (this == src) {
       // Can always assign to things of the same type
@@ -1526,7 +1575,8 @@
     kDumpClassInitialized = (1 << 2),
   };
 
-  void DumpClass(std::ostream& os, int flags) const;
+  void DumpClass(std::ostream& os, int flags) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   DexCache* GetDexCache() const;
 
@@ -1546,11 +1596,13 @@
                    new_direct_methods, false);
   }
 
-  Method* GetDirectMethod(int32_t i) const {
+  Method* GetDirectMethod(int32_t i) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetDirectMethods()->Get(i);
   }
 
-  void SetDirectMethod(uint32_t i, Method* f) {  // TODO: uint16_t
+  void SetDirectMethod(uint32_t i, Method* f)  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_){
     ObjectArray<Method>* direct_methods =
         GetFieldObject<ObjectArray<Method>*>(
             OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
@@ -1581,17 +1633,20 @@
     return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
   }
 
-  Method* GetVirtualMethod(uint32_t i) const {
+  Method* GetVirtualMethod(uint32_t i) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(IsResolved() || IsErroneous());
     return GetVirtualMethods()->Get(i);
   }
 
-  Method* GetVirtualMethodDuringLinking(uint32_t i) const {
+  Method* GetVirtualMethodDuringLinking(uint32_t i) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(IsLoaded() || IsErroneous());
     return GetVirtualMethods()->Get(i);
   }
 
-  void SetVirtualMethod(uint32_t i, Method* f) {  // TODO: uint16_t
+  void SetVirtualMethod(uint32_t i, Method* f)  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ObjectArray<Method>* virtual_methods =
         GetFieldObject<ObjectArray<Method>*>(
             OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
@@ -1619,7 +1674,8 @@
   // Given a method implemented by this class but potentially from a
   // super class, return the specific implementation
   // method for this class.
-  Method* FindVirtualMethodForVirtual(Method* method) {
+  Method* FindVirtualMethodForVirtual(Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(!method->GetDeclaringClass()->IsInterface());
     // The argument method may from a super class.
     // Use the index to a potentially overridden one for this instance's class.
@@ -1629,13 +1685,17 @@
   // Given a method implemented by this class, but potentially from a
   // super class or interface, return the specific implementation
   // method for this class.
-  Method* FindVirtualMethodForInterface(Method* method);
+  Method* FindVirtualMethodForInterface(Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const;
+  Method* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const;
+  Method* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindVirtualMethodForVirtualOrInterface(Method* method) {
+  Method* FindVirtualMethodForVirtualOrInterface(Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (method->IsDirect()) {
       return method;
     }
@@ -1645,21 +1705,29 @@
     return FindVirtualMethodForVirtual(method);
   }
 
-  Method* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const;
+  Method* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const;
+  Method* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const;
+  Method* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const;
+  Method* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const;
+  Method* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const;
+  Method* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const;
+  Method* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const;
+  Method* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   int32_t GetIfTableCount() const {
     ObjectArray<InterfaceEntry>* iftable = GetIfTable();
@@ -1695,12 +1763,14 @@
     return (GetIFields() != NULL) ? GetIFields()->GetLength() : 0;
   }
 
-  Field* GetInstanceField(uint32_t i) const {  // TODO: uint16_t
+  Field* GetInstanceField(uint32_t i) const  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_){
     DCHECK_NE(NumInstanceFields(), 0U);
     return GetIFields()->Get(i);
   }
 
-  void SetInstanceField(uint32_t i, Field* f) {  // TODO: uint16_t
+  void SetInstanceField(uint32_t i, Field* f)  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_){
     ObjectArray<Field>* ifields= GetFieldObject<ObjectArray<Field>*>(
         OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
     ifields->Set(i, f);
@@ -1770,11 +1840,13 @@
     return (GetSFields() != NULL) ? GetSFields()->GetLength() : 0;
   }
 
-  Field* GetStaticField(uint32_t i) const {  // TODO: uint16_t
+  Field* GetStaticField(uint32_t i) const  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetSFields()->Get(i);
   }
 
-  void SetStaticField(uint32_t i, Field* f) {  // TODO: uint16_t
+  void SetStaticField(uint32_t i, Field* f)  // TODO: uint16_t
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ObjectArray<Field>* sfields= GetFieldObject<ObjectArray<Field>*>(
         OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
     sfields->Set(i, f);
@@ -1787,29 +1859,38 @@
   void SetReferenceStaticOffsets(uint32_t new_reference_offsets);
 
   // Find a static or instance field using the JLS resolution order
-  Field* FindField(const StringPiece& name, const StringPiece& type);
+  Field* FindField(const StringPiece& name, const StringPiece& type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the given instance field in this class or a superclass.
-  Field* FindInstanceField(const StringPiece& name, const StringPiece& type);
+  Field* FindInstanceField(const StringPiece& name, const StringPiece& type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the given instance field in this class or a superclass, only searches classes that
   // have the same dex cache.
-  Field* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx);
+  Field* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type);
+  Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Field* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx);
+  Field* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the given static field in this class or a superclass.
-  Field* FindStaticField(const StringPiece& name, const StringPiece& type);
+  Field* FindStaticField(const StringPiece& name, const StringPiece& type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the given static field in this class or superclass, only searches classes that
   // have the same dex cache.
-  Field* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx);
+  Field* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type);
+  Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Field* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx);
+  Field* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   pid_t GetClinitThreadId() const {
     DCHECK(IsIdxLoaded() || IsErroneous());
@@ -1834,14 +1915,18 @@
   }
 
  private:
-  void SetVerifyErrorClass(Class* klass) {
+  void SetVerifyErrorClass(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(klass != NULL) << PrettyClass(this);
     SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), klass, false);
   }
 
-  bool Implements(const Class* klass) const;
-  bool IsArrayAssignableFromArray(const Class* klass) const;
-  bool IsAssignableFromArray(const Class* klass) const;
+  bool Implements(const Class* klass) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool IsArrayAssignableFromArray(const Class* klass) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool IsAssignableFromArray(const Class* klass) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // defining class loader, or NULL for the "bootstrap" system loader
   ClassLoader* class_loader_;
@@ -1995,8 +2080,7 @@
 
 inline bool Object::IsField() const {
   Class* java_lang_Class = klass_->klass_;
-  Class* java_lang_reflect_Field =
-      java_lang_Class->GetInstanceField(0)->GetClass();
+  Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass();
   return GetClass() == java_lang_reflect_Field;
 }
 
@@ -2178,7 +2262,8 @@
  public:
   typedef T ElementType;
 
-  static PrimitiveArray<T>* Alloc(size_t length);
+  static PrimitiveArray<T>* Alloc(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   const T* GetData() const {
     intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(sizeof(T)).Int32Value();
@@ -2190,14 +2275,14 @@
     return reinterpret_cast<T*>(data);
   }
 
-  T Get(int32_t i) const {
+  T Get(int32_t i) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (!IsValidIndex(i)) {
       return T(0);
     }
     return GetData()[i];
   }
 
-  void Set(int32_t i, T value) {
+  void Set(int32_t i, T value) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // TODO: ArrayStoreException
     if (IsValidIndex(i)) {
       GetData()[i] = value;
@@ -2251,9 +2336,9 @@
 
   int32_t GetLength() const;
 
-  int32_t GetHashCode();
+  int32_t GetHashCode() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void ComputeHashCode() {
+  void ComputeHashCode() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     SetHashCode(ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()));
   }
 
@@ -2261,36 +2346,44 @@
     return CountUtf8Bytes(GetCharArray()->GetData() + GetOffset(), GetLength());
   }
 
-  uint16_t CharAt(int32_t index) const;
+  uint16_t CharAt(int32_t index) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  String* Intern();
+  String* Intern() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static String* AllocFromUtf16(int32_t utf16_length,
                                 const uint16_t* utf16_data_in,
-                                int32_t hash_code = 0);
+                                int32_t hash_code = 0)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static String* AllocFromModifiedUtf8(const char* utf);
+  static String* AllocFromModifiedUtf8(const char* utf)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static String* AllocFromModifiedUtf8(int32_t utf16_length,
-                                       const char* utf8_data_in);
+                                       const char* utf8_data_in)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static String* Alloc(Class* java_lang_String, int32_t utf16_length);
+  static String* Alloc(Class* java_lang_String, int32_t utf16_length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static String* Alloc(Class* java_lang_String, CharArray* array);
+  static String* Alloc(Class* java_lang_String, CharArray* array)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool Equals(const char* modified_utf8) const;
+  bool Equals(const char* modified_utf8) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // TODO: do we need this overload? give it a more intention-revealing name.
-  bool Equals(const StringPiece& modified_utf8) const;
+  bool Equals(const StringPiece& modified_utf8) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool Equals(const String* that) const;
+  bool Equals(const String* that) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Compare UTF-16 code point values not in a locale-sensitive manner
   int Compare(int32_t utf16_length, const char* utf8_data_in);
 
   // TODO: do we need this overload? give it a more intention-revealing name.
   bool Equals(const uint16_t* that_chars, int32_t that_offset,
-              int32_t that_length) const;
+              int32_t that_length) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Create a modified UTF-8 encoded std::string from a java/lang/String object.
   std::string ToModifiedUtf8() const;
@@ -2343,6 +2436,7 @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
+// TODO: remove? only used in a unit test of itself.
 struct StringHashCode {
   int32_t operator()(String* string) const {
     return string->GetHashCode();
@@ -2425,13 +2519,13 @@
   String* GetDetailMessage() const {
     return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), false);
   }
-  std::string Dump() const;
+  std::string Dump() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // This is a runtime version of initCause, you shouldn't use it if initCause may have been
   // overridden. Also it asserts rather than throwing exceptions. Currently this is only used
   // in cases like the verifier where the checks cannot fail and initCause isn't overridden.
   void SetCause(Throwable* cause);
-  bool IsCheckedException() const;
+  bool IsCheckedException() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static Class* GetJavaLangThrowable() {
     DCHECK(java_lang_Throwable_ != NULL);
@@ -2485,7 +2579,8 @@
   static StackTraceElement* Alloc(String* declaring_class,
                                   String* method_name,
                                   String* file_name,
-                                  int32_t line_number);
+                                  int32_t line_number)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static void SetClass(Class* java_lang_StackTraceElement);
 
@@ -2511,20 +2606,20 @@
 
 class MANAGED InterfaceEntry : public ObjectArray<Object> {
  public:
-  Class* GetInterface() const {
+  Class* GetInterface() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* interface = Get(kInterface)->AsClass();
     DCHECK(interface != NULL);
     return interface;
   }
 
-  void SetInterface(Class* interface) {
+  void SetInterface(Class* interface) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(interface != NULL);
     DCHECK(interface->IsInterface());
     DCHECK(Get(kInterface) == NULL);
     Set(kInterface, interface);
   }
 
-  size_t GetMethodArrayCount() const {
+  size_t GetMethodArrayCount() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
     if (method_array == NULL) {
       return 0;
@@ -2532,13 +2627,15 @@
     return method_array->GetLength();
   }
 
-  ObjectArray<Method>* GetMethodArray() const {
+  ObjectArray<Method>* GetMethodArray() const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
     DCHECK(method_array != NULL);
     return method_array;
   }
 
-  void SetMethodArray(ObjectArray<Method>* new_ma) {
+  void SetMethodArray(ObjectArray<Method>* new_ma)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(new_ma != NULL);
     DCHECK(Get(kMethodArray) == NULL);
     Set(kMethodArray, new_ma);
diff --git a/src/object_test.cc b/src/object_test.cc
index c0049a3..bbb96c6 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -34,7 +34,8 @@
   void AssertString(int32_t length,
                     const char* utf8_in,
                     const char* utf16_expected_le,
-                    int32_t expected_hash) {
+                    int32_t expected_hash)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     UniquePtr<uint16_t[]> utf16_expected(new uint16_t[length]);
     for (int32_t i = 0; i < length; i++) {
       uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
@@ -74,6 +75,7 @@
 }
 
 TEST_F(ObjectTest, Clone) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<ObjectArray<Object> > a1(class_linker_->AllocObjectArray<Object>(256));
   size_t s1 = a1->SizeOf();
   Object* clone = a1->Clone();
@@ -82,6 +84,7 @@
 }
 
 TEST_F(ObjectTest, AllocObjectArray) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<ObjectArray<Object> > oa(class_linker_->AllocObjectArray<Object>(2));
   EXPECT_EQ(2, oa->GetLength());
   EXPECT_TRUE(oa->Get(0) == NULL);
@@ -114,6 +117,7 @@
 }
 
 TEST_F(ObjectTest, AllocArray) {
+  ScopedObjectAccess soa(Thread::Current());
   Class* c = class_linker_->FindSystemClass("[I");
   SirtRef<Array> a(Array::Alloc(c, 1));
   ASSERT_TRUE(c == a->GetClass());
@@ -129,6 +133,7 @@
 
 template<typename ArrayT>
 void TestPrimitiveArray(ClassLinker* cl) {
+  ScopedObjectAccess soa(Thread::Current());
   typedef typename ArrayT::ElementType T;
 
   ArrayT* a = ArrayT::Alloc(2);
@@ -183,6 +188,7 @@
 
 TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
   // pretend we are trying to call 'new char[3]' from String.toCharArray
+  ScopedObjectAccess soa(Thread::Current());
   Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
   Method* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
   const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
@@ -200,11 +206,13 @@
 
 TEST_F(ObjectTest, StaticFieldFromCode) {
   // pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit>
-  SirtRef<ClassLoader> class_loader(LoadDex("StaticsFromCode"));
-  const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(class_loader.get())[0];
+  ScopedObjectAccess soa(Thread::Current());
+  jobject class_loader = LoadDex("StaticsFromCode");
+  const DexFile* dex_file = Runtime::Current()->GetCompileTimeClassPath(class_loader)[0];
   CHECK(dex_file != NULL);
 
-  Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
+  Class* klass =
+      class_linker_->FindClass("LStaticsFromCode;", soa.Decode<ClassLoader*>(class_loader));
   Method* clinit = klass->FindDirectMethod("<clinit>", "()V");
   const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
   ASSERT_TRUE(klass_string_id != NULL);
@@ -242,6 +250,7 @@
 }
 
 TEST_F(ObjectTest, String) {
+  ScopedObjectAccess soa(Thread::Current());
   // Test the empty string.
   AssertString(0, "",     "", 0);
 
@@ -265,6 +274,7 @@
 }
 
 TEST_F(ObjectTest, StringEqualsUtf8) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
   EXPECT_TRUE(string->Equals("android"));
   EXPECT_FALSE(string->Equals("Android"));
@@ -279,6 +289,7 @@
 }
 
 TEST_F(ObjectTest, StringEquals) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
   SirtRef<String> string_2(String::AllocFromModifiedUtf8("android"));
   EXPECT_TRUE(string->Equals(string_2.get()));
@@ -294,6 +305,7 @@
 }
 
 TEST_F(ObjectTest, StringLength) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> string(String::AllocFromModifiedUtf8("android"));
   EXPECT_EQ(string->GetLength(), 7);
   EXPECT_EQ(string->GetUtfLength(), 7);
@@ -306,10 +318,13 @@
 }
 
 TEST_F(ObjectTest, DescriptorCompare) {
+  ScopedObjectAccess soa(Thread::Current());
   ClassLinker* linker = class_linker_;
 
-  SirtRef<ClassLoader> class_loader_1(LoadDex("ProtoCompare"));
-  SirtRef<ClassLoader> class_loader_2(LoadDex("ProtoCompare2"));
+  jobject jclass_loader_1 = LoadDex("ProtoCompare");
+  jobject jclass_loader_2 = LoadDex("ProtoCompare2");
+  SirtRef<ClassLoader> class_loader_1(soa.Decode<ClassLoader*>(jclass_loader_1));
+  SirtRef<ClassLoader> class_loader_2(soa.Decode<ClassLoader*>(jclass_loader_2));
 
   Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1.get());
   ASSERT_TRUE(klass1 != NULL);
@@ -365,6 +380,7 @@
 
 
 TEST_F(ObjectTest, StringHashCode) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> empty(String::AllocFromModifiedUtf8(""));
   SirtRef<String> A(String::AllocFromModifiedUtf8("A"));
   SirtRef<String> ABC(String::AllocFromModifiedUtf8("ABC"));
@@ -375,7 +391,10 @@
 }
 
 TEST_F(ObjectTest, InstanceOf) {
-  SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
+  ScopedObjectAccess soa(Thread::Current());
+  jobject jclass_loader = LoadDex("XandY");
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
+
   Class* X = class_linker_->FindClass("LX;", class_loader.get());
   Class* Y = class_linker_->FindClass("LY;", class_loader.get());
   ASSERT_TRUE(X != NULL);
@@ -406,7 +425,9 @@
 }
 
 TEST_F(ObjectTest, IsAssignableFrom) {
-  SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
+  ScopedObjectAccess soa(Thread::Current());
+  jobject jclass_loader = LoadDex("XandY");
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
   Class* X = class_linker_->FindClass("LX;", class_loader.get());
   Class* Y = class_linker_->FindClass("LY;", class_loader.get());
 
@@ -441,7 +462,9 @@
 }
 
 TEST_F(ObjectTest, IsAssignableFromArray) {
-  SirtRef<ClassLoader> class_loader(LoadDex("XandY"));
+  ScopedObjectAccess soa(Thread::Current());
+  jobject jclass_loader = LoadDex("XandY");
+  SirtRef<ClassLoader> class_loader(soa.Decode<ClassLoader*>(jclass_loader));
   Class* X = class_linker_->FindClass("LX;", class_loader.get());
   Class* Y = class_linker_->FindClass("LY;", class_loader.get());
   ASSERT_TRUE(X != NULL);
@@ -492,6 +515,7 @@
 }
 
 TEST_F(ObjectTest, FindInstanceField) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
   ASSERT_TRUE(s.get() != NULL);
   Class* c = s->GetClass();
@@ -524,6 +548,7 @@
 }
 
 TEST_F(ObjectTest, FindStaticField) {
+  ScopedObjectAccess soa(Thread::Current());
   SirtRef<String> s(String::AllocFromModifiedUtf8("ABC"));
   ASSERT_TRUE(s.get() != NULL);
   Class* c = s->GetClass();
diff --git a/src/object_utils.h b/src/object_utils.h
index 8b2aab9..d523ecc 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -32,29 +32,30 @@
 
 class ObjectLock {
  public:
-  explicit ObjectLock(Object* object) : self_(Thread::Current()), obj_(object) {
+  explicit ObjectLock(Object* object) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      : self_(Thread::Current()), obj_(object) {
     CHECK(object != NULL);
     obj_->MonitorEnter(self_);
   }
 
-  ~ObjectLock() {
+  ~ObjectLock() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     obj_->MonitorExit(self_);
   }
 
-  void Wait() {
+  void Wait() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return Monitor::Wait(self_, obj_, 0, 0, false);
   }
 
-  void Notify() {
+  void Notify() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     obj_->Notify();
   }
 
-  void NotifyAll() {
+  void NotifyAll() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     obj_->NotifyAll();
   }
 
  private:
-  Thread* self_;
+  Thread* const self_;
   Object* obj_;
   DISALLOW_COPY_AND_ASSIGN(ObjectLock);
 };
@@ -62,6 +63,7 @@
 class ClassHelper {
  public:
   ClassHelper(const Class* c = NULL, ClassLinker* l = NULL)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : class_def_(NULL),
         class_linker_(l),
         dex_cache_(NULL),
@@ -73,7 +75,8 @@
     }
   }
 
-  void ChangeClass(const Class* new_c) {
+  void ChangeClass(const Class* new_c)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(new_c != NULL) << "klass_=" << klass_;  // Log what we were changing from if any
     CHECK(new_c->IsClass()) << "new_c=" << new_c;
     if (dex_cache_ != NULL) {
@@ -90,7 +93,7 @@
 
   // The returned const char* is only guaranteed to be valid for the lifetime of the ClassHelper.
   // If you need it longer, copy it into a std::string.
-  const char* GetDescriptor() {
+  const char* GetDescriptor() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK(klass_ != NULL);
     if (UNLIKELY(klass_->IsArrayClass())) {
       return GetArrayDescriptor();
@@ -106,7 +109,7 @@
     }
   }
 
-  const char* GetArrayDescriptor() {
+  const char* GetArrayDescriptor() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::string result("[");
     const Class* saved_klass = klass_;
     CHECK(saved_klass != NULL);
@@ -117,7 +120,8 @@
     return descriptor_.c_str();
   }
 
-  const DexFile::ClassDef* GetClassDef() {
+  const DexFile::ClassDef* GetClassDef()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile::ClassDef* result = class_def_;
     if (result == NULL) {
       result = GetDexFile().FindClassDef(GetDescriptor());
@@ -126,7 +130,7 @@
     return result;
   }
 
-  uint32_t NumDirectInterfaces() {
+  uint32_t NumDirectInterfaces() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(klass_ != NULL);
     if (klass_->IsPrimitive()) {
       return 0;
@@ -144,14 +148,16 @@
     }
   }
 
-  uint16_t GetDirectInterfaceTypeIdx(uint32_t idx) {
+  uint16_t GetDirectInterfaceTypeIdx(uint32_t idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(klass_ != NULL);
     DCHECK(!klass_->IsPrimitive());
     DCHECK(!klass_->IsArrayClass());
     return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_;
   }
 
-  Class* GetDirectInterface(uint32_t idx) {
+  Class* GetDirectInterface(uint32_t idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(klass_ != NULL);
     DCHECK(!klass_->IsPrimitive());
     if (klass_->IsArrayClass()) {
@@ -174,7 +180,7 @@
     }
   }
 
-  const char* GetSourceFile() {
+  const char* GetSourceFile() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     std::string descriptor(GetDescriptor());
     const DexFile& dex_file = GetDexFile();
     const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
@@ -182,7 +188,7 @@
     return dex_file.GetSourceFile(*dex_class_def);
   }
 
-  std::string GetLocation() {
+  std::string GetLocation() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DexCache* dex_cache = GetDexCache();
     if (dex_cache != NULL && !klass_->IsProxyClass()) {
       return dex_cache->GetLocation()->ToModifiedUtf8();
@@ -192,7 +198,7 @@
     }
   }
 
-  const DexFile& GetDexFile() {
+  const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile* result = dex_file_;
     if (result == NULL) {
       const DexCache* dex_cache = GetDexCache();
@@ -202,7 +208,7 @@
     return *result;
   }
 
-  DexCache* GetDexCache() {
+  DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DexCache* result = dex_cache_;
     if (result == NULL) {
       DCHECK(klass_ != NULL);
@@ -213,7 +219,8 @@
   }
 
  private:
-  const DexFile::TypeList* GetInterfaceTypeList() {
+  const DexFile::TypeList* GetInterfaceTypeList()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile::TypeList* result = interface_type_list_;
     if (result == NULL) {
       const DexFile::ClassDef* class_def = GetClassDef();
@@ -263,7 +270,7 @@
     }
     field_ = new_f;
   }
-  const char* GetName() {
+  const char* GetName() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     uint32_t field_index = field_->GetDexFieldIndex();
     if (!field_->GetDeclaringClass()->IsProxyClass()) {
       const DexFile& dex_file = GetDexFile();
@@ -284,7 +291,7 @@
       return Runtime::Current()->GetInternTable()->InternStrong(GetName());
     }
   }
-  Class* GetType() {
+  Class* GetType() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     uint32_t field_index = field_->GetDexFieldIndex();
     if (!field_->GetDeclaringClass()->IsProxyClass()) {
       const DexFile& dex_file = GetDexFile();
@@ -299,7 +306,7 @@
       return GetClassLinker()->FindSystemClass(GetTypeDescriptor());
     }
   }
-  const char* GetTypeDescriptor() {
+  const char* GetTypeDescriptor() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     uint32_t field_index = field_->GetDexFieldIndex();
     if (!field_->GetDeclaringClass()->IsProxyClass()) {
       const DexFile& dex_file = GetDexFile();
@@ -312,27 +319,29 @@
       return field_index == 0 ? "[Ljava/lang/Class;" : "[[Ljava/lang/Class;";
     }
   }
-  Primitive::Type GetTypeAsPrimitiveType() {
+  Primitive::Type GetTypeAsPrimitiveType()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return Primitive::GetType(GetTypeDescriptor()[0]);
   }
-  bool IsPrimitiveType() {
+  bool IsPrimitiveType() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Primitive::Type type = GetTypeAsPrimitiveType();
     return type != Primitive::kPrimNot;
   }
-  size_t FieldSize() {
+  size_t FieldSize() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Primitive::Type type = GetTypeAsPrimitiveType();
     return Primitive::FieldSize(type);
   }
 
   // The returned const char* is only guaranteed to be valid for the lifetime of the FieldHelper.
   // If you need it longer, copy it into a std::string.
-  const char* GetDeclaringClassDescriptor() {
+  const char* GetDeclaringClassDescriptor()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     uint16_t type_idx = field_->GetDeclaringClass()->GetDexTypeIndex();
     if (type_idx != DexFile::kDexNoIndex16) {
       const DexFile& dex_file = GetDexFile();
       return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
     } else {
-      // Most likely a proxy class
+      // Most likely a proxy class.
       ClassHelper kh(field_->GetDeclaringClass());
       declaring_class_descriptor_ = kh.GetDescriptor();
       return declaring_class_descriptor_.c_str();
@@ -340,7 +349,7 @@
   }
 
  private:
-  DexCache* GetDexCache() {
+  DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DexCache* result = dex_cache_;
     if (result == NULL) {
       result = field_->GetDeclaringClass()->GetDexCache();
@@ -356,7 +365,7 @@
     }
     return result;
   }
-  const DexFile& GetDexFile() {
+  const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile* result = dex_file_;
     if (result == NULL) {
       const DexCache* dex_cache = GetDexCache();
@@ -378,22 +387,24 @@
 class MethodHelper {
  public:
   MethodHelper()
-      : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
-        shorty_len_(0) {}
+     : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
+       shorty_len_(0) {}
 
   explicit MethodHelper(const Method* m)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
         shorty_len_(0) {
     SetMethod(m);
   }
 
   MethodHelper(const Method* m, ClassLinker* l)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : class_linker_(l), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
         shorty_len_(0) {
     SetMethod(m);
   }
 
-  void ChangeMethod(Method* new_m) {
+  void ChangeMethod(Method* new_m) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(new_m != NULL);
     if (dex_cache_ != NULL) {
       Class* klass = new_m->GetDeclaringClass();
@@ -412,7 +423,7 @@
     shorty_ = NULL;
   }
 
-  const char* GetName() {
+  const char* GetName() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
     if (dex_method_idx != DexFile::kDexNoIndex16) {
@@ -433,14 +444,15 @@
     }
   }
 
-  String* GetNameAsString() {
+  String* GetNameAsString() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
     const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
     return GetClassLinker()->ResolveString(dex_file, method_id.name_idx_, GetDexCache());
   }
 
-  const char* GetShorty() {
+  const char* GetShorty() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const char* result = shorty_;
     if (result == NULL) {
       const DexFile& dex_file = GetDexFile();
@@ -451,14 +463,14 @@
     return result;
   }
 
-  uint32_t GetShortyLength() {
+  uint32_t GetShortyLength() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (shorty_ == NULL) {
       GetShorty();
     }
     return shorty_len_;
   }
 
-  const std::string GetSignature() {
+  const std::string GetSignature() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     uint32_t dex_method_idx = method_->GetDexMethodIndex();
     if (dex_method_idx != DexFile::kDexNoIndex16) {
@@ -468,17 +480,20 @@
     }
   }
 
-  const DexFile::ProtoId& GetPrototype() {
+  const DexFile::ProtoId& GetPrototype()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     return dex_file.GetMethodPrototype(dex_file.GetMethodId(method_->GetDexMethodIndex()));
   }
 
-  const DexFile::TypeList* GetParameterTypeList() {
+  const DexFile::TypeList* GetParameterTypeList()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile::ProtoId& proto = GetPrototype();
     return GetDexFile().GetProtoParameters(proto);
   }
 
-  ObjectArray<Class>* GetParameterTypes() {
+  ObjectArray<Class>* GetParameterTypes()
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile::TypeList* params = GetParameterTypeList();
     Class* array_class = GetClassLinker()->FindSystemClass("[Ljava/lang/Class;");
     uint32_t num_params = params == NULL ? 0 : params->Size();
@@ -494,7 +509,7 @@
     return result;
   }
 
-  Class* GetReturnType() {
+  Class* GetReturnType() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
     const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
@@ -502,7 +517,8 @@
     return GetClassFromTypeIdx(return_type_idx);
   }
 
-  const char* GetReturnTypeDescriptor() {
+  const char* GetReturnTypeDescriptor()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
     const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
@@ -510,7 +526,8 @@
     return dex_file.GetTypeDescriptor(dex_file.GetTypeId(return_type_idx));
   }
 
-  int32_t GetLineNumFromDexPC(uint32_t dex_pc) {
+  int32_t GetLineNumFromDexPC(uint32_t dex_pc)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (dex_pc == DexFile::kDexNoIndex) {
       return method_->IsNative() ? -2 : -1;
     } else {
@@ -519,7 +536,8 @@
     }
   }
 
-  const char* GetDeclaringClassDescriptor() {
+  const char* GetDeclaringClassDescriptor()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* klass = method_->GetDeclaringClass();
     DCHECK(!klass->IsProxyClass());
     uint16_t type_idx = klass->GetDexTypeIndex();
@@ -527,7 +545,8 @@
     return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
   }
 
-  const char* GetDeclaringClassSourceFile() {
+  const char* GetDeclaringClassSourceFile()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const char* descriptor = GetDeclaringClassDescriptor();
     const DexFile& dex_file = GetDexFile();
     const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
@@ -535,7 +554,8 @@
     return dex_file.GetSourceFile(*dex_class_def);
   }
 
-  uint32_t GetClassDefIndex() {
+  uint32_t GetClassDefIndex()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const char* descriptor = GetDeclaringClassDescriptor();
     const DexFile& dex_file = GetDexFile();
     uint32_t index;
@@ -543,26 +563,29 @@
     return index;
   }
 
-  ClassLoader* GetClassLoader() {
+  ClassLoader* GetClassLoader()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return method_->GetDeclaringClass()->GetClassLoader();
   }
 
-  bool IsStatic() {
+  bool IsStatic()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return method_->IsStatic();
   }
 
-  bool IsClassInitializer() {
+  bool IsClassInitializer() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return IsStatic() && StringPiece(GetName()) == "<clinit>";
   }
 
-  size_t NumArgs() {
+  size_t NumArgs() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // "1 +" because the first in Args is the receiver.
     // "- 1" because we don't count the return type.
     return (IsStatic() ? 0 : 1) + GetShortyLength() - 1;
   }
 
   // Is the specified parameter a long or double, where parameter 0 is 'this' for instance methods
-  bool IsParamALongOrDouble(size_t param) {
+  bool IsParamALongOrDouble(size_t param)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK_LT(param, NumArgs());
     if (IsStatic()) {
       param++;  // 0th argument must skip return value at start of the shorty
@@ -574,7 +597,7 @@
   }
 
   // Is the specified parameter a reference, where parameter 0 is 'this' for instance methods
-  bool IsParamAReference(size_t param) {
+  bool IsParamAReference(size_t param) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     CHECK_LT(param, NumArgs());
     if (IsStatic()) {
       param++;  // 0th argument must skip return value at start of the shorty
@@ -584,7 +607,8 @@
     return GetShorty()[param] == 'L';  // An array also has a shorty character of 'L' (not '[')
   }
 
-  bool HasSameNameAndSignature(MethodHelper* other) {
+  bool HasSameNameAndSignature(MethodHelper* other)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (GetDexCache() == other->GetDexCache()) {
       const DexFile& dex_file = GetDexFile();
       const DexFile::MethodId& mid = dex_file.GetMethodId(method_->GetDexMethodIndex());
@@ -597,15 +621,18 @@
     return name == other_name && GetSignature() == other->GetSignature();
   }
 
-  const DexFile::CodeItem* GetCodeItem() {
+  const DexFile::CodeItem* GetCodeItem()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetDexFile().GetCodeItem(method_->GetCodeItemOffset());
   }
 
-  bool IsResolvedTypeIdx(uint16_t type_idx) const {
+  bool IsResolvedTypeIdx(uint16_t type_idx) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return method_->GetDexCacheResolvedTypes()->Get(type_idx) != NULL;
   }
 
-  Class* GetClassFromTypeIdx(uint16_t type_idx) {
+  Class* GetClassFromTypeIdx(uint16_t type_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* type = method_->GetDexCacheResolvedTypes()->Get(type_idx);
     if (type == NULL) {
       type = GetClassLinker()->ResolveType(type_idx, method_);
@@ -614,16 +641,18 @@
     return type;
   }
 
-  const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx) {
+  const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile& dex_file = GetDexFile();
     return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
   }
 
-  Class* GetDexCacheResolvedType(uint16_t type_idx) {
+  Class* GetDexCacheResolvedType(uint16_t type_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetDexCache()->GetResolvedType(type_idx);
   }
 
-  const DexFile& GetDexFile() {
+  const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     const DexFile* result = dex_file_;
     if (result == NULL) {
       const DexCache* dex_cache = GetDexCache();
@@ -633,7 +662,7 @@
     return *result;
   }
 
-  DexCache* GetDexCache() {
+  DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DexCache* result = dex_cache_;
     if (result == NULL) {
       Class* klass = method_->GetDeclaringClass();
@@ -646,7 +675,8 @@
  private:
   // Set the method_ field, for proxy methods looking up the interface method via the resolved
   // methods table.
-  void SetMethod(const Method* method) {
+  void SetMethod(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (method != NULL) {
       Class* klass = method->GetDeclaringClass();
       if (klass->IsProxyClass()) {
diff --git a/src/reference_table.cc b/src/reference_table.cc
index ee1760b..a2b54d6 100644
--- a/src/reference_table.cc
+++ b/src/reference_table.cc
@@ -60,7 +60,10 @@
 }
 
 struct ObjectComparator {
-  bool operator()(const Object* obj1, const Object* obj2) {
+  bool operator()(const Object* obj1, const Object* obj2)
+    // TODO: enable analysis when analysis can work with the STL.
+      NO_THREAD_SAFETY_ANALYSIS {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
     // Ensure null references and cleared jweaks appear at the end.
     if (obj1 == NULL) {
       return true;
@@ -75,8 +78,7 @@
 
     // Sort by class...
     if (obj1->GetClass() != obj2->GetClass()) {
-      return reinterpret_cast<uintptr_t>(obj1->GetClass()) <
-          reinterpret_cast<uintptr_t>(obj2->GetClass());
+      return obj1->GetClass()->IdentityHashCode() < obj2->IdentityHashCode();
     } else {
       // ...then by size...
       size_t count1 = obj1->SizeOf();
@@ -84,9 +86,8 @@
       if (count1 != count2) {
         return count1 < count2;
       } else {
-        // ...and finally by address.
-        return reinterpret_cast<uintptr_t>(obj1) <
-            reinterpret_cast<uintptr_t>(obj2);
+        // ...and finally by identity hash code.
+        return obj1->IdentityHashCode() < obj2->IdentityHashCode();
       }
     }
   }
@@ -97,7 +98,9 @@
 // Pass in the number of elements in the array (or 0 if this is not an
 // array object), and the number of additional objects that are identical
 // or equivalent to the original.
-static void DumpSummaryLine(std::ostream& os, const Object* obj, size_t element_count, int identical, int equiv) {
+static void DumpSummaryLine(std::ostream& os, const Object* obj, size_t element_count,
+                            int identical, int equiv)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (obj == NULL) {
     os << "    NULL reference (count=" << equiv << ")\n";
     return;
diff --git a/src/reference_table.h b/src/reference_table.h
index 28af887..de9d45d 100644
--- a/src/reference_table.h
+++ b/src/reference_table.h
@@ -43,13 +43,14 @@
 
   size_t Size() const;
 
-  void Dump(std::ostream& os) const;
+  void Dump(std::ostream& os) const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void VisitRoots(Heap::RootVisitor* visitor, void* arg);
 
  private:
   typedef std::vector<const Object*> Table;
-  static void Dump(std::ostream& os, const Table& entries);
+  static void Dump(std::ostream& os, const Table& entries)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   friend class IndirectReferenceTable; // For Dump.
 
   std::string name_;
diff --git a/src/reference_table_test.cc b/src/reference_table_test.cc
index c7c1cc6..4bb5c97 100644
--- a/src/reference_table_test.cc
+++ b/src/reference_table_test.cc
@@ -24,6 +24,7 @@
 };
 
 TEST_F(ReferenceTableTest, Basics) {
+  ScopedObjectAccess soa(Thread::Current());
   Object* o1 = String::AllocFromModifiedUtf8("hello");
   Object* o2 = ShortArray::Alloc(0);
 
diff --git a/src/reflection.cc b/src/reflection.cc
index 7726998..542f1a2 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -20,35 +20,15 @@
 #include "jni_internal.h"
 #include "object.h"
 #include "object_utils.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
+#include "well_known_classes.h"
 
 namespace art {
 
-Method* gBoolean_valueOf;
-Method* gByte_valueOf;
-Method* gCharacter_valueOf;
-Method* gDouble_valueOf;
-Method* gFloat_valueOf;
-Method* gInteger_valueOf;
-Method* gLong_valueOf;
-Method* gShort_valueOf;
-
-void InitBoxingMethods() {
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-  gBoolean_valueOf = class_linker->FindSystemClass("Ljava/lang/Boolean;")->FindDeclaredDirectMethod("valueOf", "(Z)Ljava/lang/Boolean;");
-  gByte_valueOf = class_linker->FindSystemClass("Ljava/lang/Byte;")->FindDeclaredDirectMethod("valueOf", "(B)Ljava/lang/Byte;");
-  gCharacter_valueOf = class_linker->FindSystemClass("Ljava/lang/Character;")->FindDeclaredDirectMethod("valueOf", "(C)Ljava/lang/Character;");
-  gDouble_valueOf = class_linker->FindSystemClass("Ljava/lang/Double;")->FindDeclaredDirectMethod("valueOf", "(D)Ljava/lang/Double;");
-  gFloat_valueOf = class_linker->FindSystemClass("Ljava/lang/Float;")->FindDeclaredDirectMethod("valueOf", "(F)Ljava/lang/Float;");
-  gInteger_valueOf = class_linker->FindSystemClass("Ljava/lang/Integer;")->FindDeclaredDirectMethod("valueOf", "(I)Ljava/lang/Integer;");
-  gLong_valueOf = class_linker->FindSystemClass("Ljava/lang/Long;")->FindDeclaredDirectMethod("valueOf", "(J)Ljava/lang/Long;");
-  gShort_valueOf = class_linker->FindSystemClass("Ljava/lang/Short;")->FindDeclaredDirectMethod("valueOf", "(S)Ljava/lang/Short;");
-}
-
-jobject InvokeMethod(const ScopedJniThreadState& ts, jobject javaMethod, jobject javaReceiver,
+jobject InvokeMethod(const ScopedObjectAccess& soa, jobject javaMethod, jobject javaReceiver,
                      jobject javaArgs) {
-  jmethodID mid = ts.Env()->FromReflectedMethod(javaMethod);
-  Method* m = ts.DecodeMethod(mid);
+  jmethodID mid = soa.Env()->FromReflectedMethod(javaMethod);
+  Method* m = soa.DecodeMethod(mid);
 
   Class* declaring_class = m->GetDeclaringClass();
   if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true, true)) {
@@ -58,24 +38,24 @@
   Object* receiver = NULL;
   if (!m->IsStatic()) {
     // Check that the receiver is non-null and an instance of the field's declaring class.
-    receiver = ts.Decode<Object*>(javaReceiver);
+    receiver = soa.Decode<Object*>(javaReceiver);
     if (!VerifyObjectInClass(receiver, declaring_class)) {
       return NULL;
     }
 
     // Find the actual implementation of the virtual method.
     m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(m);
-    mid = ts.EncodeMethod(m);
+    mid = soa.EncodeMethod(m);
   }
 
   // Get our arrays of arguments and their types, and check they're the same size.
-  ObjectArray<Object>* objects = ts.Decode<ObjectArray<Object>*>(javaArgs);
+  ObjectArray<Object>* objects = soa.Decode<ObjectArray<Object>*>(javaArgs);
   MethodHelper mh(m);
   const DexFile::TypeList* classes = mh.GetParameterTypeList();
   uint32_t classes_size = classes == NULL ? 0 : classes->Size();
   uint32_t arg_count = (objects != NULL) ? objects->GetLength() : 0;
   if (arg_count != classes_size) {
-    ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
         "wrong number of arguments; expected %d, got %d",
         classes_size, arg_count);
     return NULL;
@@ -91,27 +71,27 @@
       return NULL;
     }
     if (!dst_class->IsPrimitive()) {
-      args[i].l = ts.AddLocalReference<jobject>(arg);
+      args[i].l = soa.AddLocalReference<jobject>(arg);
     }
   }
 
   // Invoke the method.
-  JValue value(InvokeWithJValues(ts, javaReceiver, mid, args.get()));
+  JValue value(InvokeWithJValues(soa, javaReceiver, mid, args.get()));
 
   // Wrap any exception with "Ljava/lang/reflect/InvocationTargetException;" and return early.
-  if (ts.Self()->IsExceptionPending()) {
-    jthrowable th = ts.Env()->ExceptionOccurred();
-    ts.Env()->ExceptionClear();
-    jclass exception_class = ts.Env()->FindClass("java/lang/reflect/InvocationTargetException");
-    jmethodID mid = ts.Env()->GetMethodID(exception_class, "<init>", "(Ljava/lang/Throwable;)V");
-    jobject exception_instance = ts.Env()->NewObject(exception_class, mid, th);
-    ts.Env()->Throw(reinterpret_cast<jthrowable>(exception_instance));
+  if (soa.Self()->IsExceptionPending()) {
+    jthrowable th = soa.Env()->ExceptionOccurred();
+    soa.Env()->ExceptionClear();
+    jclass exception_class = soa.Env()->FindClass("java/lang/reflect/InvocationTargetException");
+    jmethodID mid = soa.Env()->GetMethodID(exception_class, "<init>", "(Ljava/lang/Throwable;)V");
+    jobject exception_instance = soa.Env()->NewObject(exception_class, mid, th);
+    soa.Env()->Throw(reinterpret_cast<jthrowable>(exception_instance));
     return NULL;
   }
 
   // Box if necessary and return.
   BoxPrimitive(mh.GetReturnType()->GetPrimitiveType(), value);
-  return ts.AddLocalReference<jobject>(value.GetL());
+  return soa.AddLocalReference<jobject>(value.GetL());
 }
 
 bool VerifyObjectInClass(Object* o, Class* c) {
@@ -220,31 +200,31 @@
     return;
   }
 
-  Method* m = NULL;
+  jmethodID m = NULL;
   switch (src_class) {
   case Primitive::kPrimBoolean:
-    m = gBoolean_valueOf;
+    m = WellKnownClasses::java_lang_Boolean_valueOf;
     break;
   case Primitive::kPrimByte:
-    m = gByte_valueOf;
+    m = WellKnownClasses::java_lang_Byte_valueOf;
     break;
   case Primitive::kPrimChar:
-    m = gCharacter_valueOf;
+    m = WellKnownClasses::java_lang_Character_valueOf;
     break;
   case Primitive::kPrimDouble:
-    m = gDouble_valueOf;
+    m = WellKnownClasses::java_lang_Double_valueOf;
     break;
   case Primitive::kPrimFloat:
-    m = gFloat_valueOf;
+    m = WellKnownClasses::java_lang_Float_valueOf;
     break;
   case Primitive::kPrimInt:
-    m = gInteger_valueOf;
+    m = WellKnownClasses::java_lang_Integer_valueOf;
     break;
   case Primitive::kPrimLong:
-    m = gLong_valueOf;
+    m = WellKnownClasses::java_lang_Long_valueOf;
     break;
   case Primitive::kPrimShort:
-    m = gShort_valueOf;
+    m = WellKnownClasses::java_lang_Short_valueOf;
     break;
   case Primitive::kPrimVoid:
     // There's no such thing as a void field, and void methods invoked via reflection return null.
@@ -254,13 +234,17 @@
     LOG(FATAL) << static_cast<int>(src_class);
   }
 
-  Thread* self = Thread::Current();
-  ScopedThreadStateChange tsc(self, kRunnable);
+  if (kIsDebugBuild) {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(Thread::Current()->GetState(), kRunnable);
+  }
+  ScopedObjectAccessUnchecked soa(Thread::Current());
   JValue args[1] = { value };
-  m->Invoke(self, NULL, args, &value);
+  soa.DecodeMethod(m)->Invoke(soa.Self(), NULL, args, &value);
 }
 
-static std::string UnboxingFailureKind(Method* m, int index, Field* f) {
+static std::string UnboxingFailureKind(Method* m, int index, Field* f)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (m != NULL && index != -1) {
     ++index; // Humans count from 1.
     return StringPrintf("method %s argument %d", PrettyMethod(m, false).c_str(), index);
@@ -271,7 +255,9 @@
   return "result";
 }
 
-static bool UnboxPrimitive(Object* o, Class* dst_class, JValue& unboxed_value, Method* m, int index, Field* f) {
+static bool UnboxPrimitive(Object* o, Class* dst_class, JValue& unboxed_value, Method* m,
+                           int index, Field* f)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (!dst_class->IsPrimitive()) {
     if (o != NULL && !o->InstanceOf(dst_class)) {
       Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
diff --git a/src/reflection.h b/src/reflection.h
index 03847f8..2979e5b 100644
--- a/src/reflection.h
+++ b/src/reflection.h
@@ -27,19 +27,27 @@
 union JValue;
 class Method;
 class Object;
-class ScopedJniThreadState;
+class ScopedObjectAccess;
 
-void InitBoxingMethods();
-void BoxPrimitive(Primitive::Type src_class, JValue& value);
-bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, Method* m, size_t index);
-bool UnboxPrimitiveForField(Object* o, Class* dst_class, JValue& unboxed_value, Field* f);
-bool UnboxPrimitiveForResult(Object* o, Class* dst_class, JValue& unboxed_value);
+void BoxPrimitive(Primitive::Type src_class, JValue& value)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, Method* m,
+                               size_t index)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+bool UnboxPrimitiveForField(Object* o, Class* dst_class, JValue& unboxed_value, Field* f)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+bool UnboxPrimitiveForResult(Object* o, Class* dst_class, JValue& unboxed_value)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-bool ConvertPrimitiveValue(Primitive::Type src_class, Primitive::Type dst_class, const JValue& src, JValue& dst);
+bool ConvertPrimitiveValue(Primitive::Type src_class, Primitive::Type dst_class, const JValue& src,
+                           JValue& dst)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-jobject InvokeMethod(const ScopedJniThreadState& ts, jobject method, jobject receiver, jobject args);
+jobject InvokeMethod(const ScopedObjectAccess& soa, jobject method, jobject receiver, jobject args)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-bool VerifyObjectInClass(Object* o, Class* c);
+bool VerifyObjectInClass(Object* o, Class* c)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 }  // namespace art
 
diff --git a/src/runtime.cc b/src/runtime.cc
index 6447ede..5230b77 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -35,9 +35,8 @@
 #include "jni_internal.h"
 #include "monitor.h"
 #include "oat_file.h"
-#include "scoped_heap_lock.h"
-#include "scoped_jni_thread_state.h"
 #include "ScopedLocalRef.h"
+#include "scoped_thread_state_change.h"
 #include "signal_catcher.h"
 #include "signal_set.h"
 #include "space.h"
@@ -118,10 +117,7 @@
   }
 
   // Make sure to let the GC complete if it is running.
-  {
-    ScopedHeapLock heap_lock;
-    heap_->WaitForConcurrentGcToComplete();
-  }
+  heap_->WaitForConcurrentGcToComplete();
 
   // Make sure our internal threads are dead before we start tearing down things they're using.
   Dbg::StopJdwp();
@@ -162,6 +158,10 @@
     if (self == NULL) {
       os << "(Aborting thread was not attached to runtime!)\n";
     } else {
+      // TODO: we're aborting and the ScopedObjectAccess may attempt to acquire the mutator_lock_
+      //       which may block indefinitely if there's a misbehaving thread holding it exclusively.
+      //       The code below should be made robust to this.
+      ScopedObjectAccess soa(self);
       self->Dump(os);
       if (self->IsExceptionPending()) {
         os << "Pending " << PrettyTypeOf(self->GetException()) << " on thread:\n"
@@ -171,15 +171,10 @@
   }
 };
 
-static Mutex& GetAbortLock() {
-  static Mutex abort_lock("abort lock");
-  return abort_lock;
-}
-
 void Runtime::Abort() {
   // Ensure that we don't have multiple threads trying to abort at once,
   // which would result in significantly worse diagnostics.
-  MutexLock mu(GetAbortLock());
+  MutexLock mu(*GlobalSynchronization::abort_lock_);
 
   // Get any pending output out of the way.
   fflush(NULL);
@@ -315,15 +310,6 @@
   return result;
 }
 
-void LoadJniLibrary(JavaVMExt* vm, const char* name) {
-  std::string mapped_name(StringPrintf(OS_SHARED_LIB_FORMAT_STR, name));
-  std::string reason;
-  if (!vm->LoadNativeLibrary(mapped_name, NULL, reason)) {
-    LOG(FATAL) << "LoadNativeLibrary failed for \"" << mapped_name << "\": "
-               << reason;
-  }
-}
-
 Runtime::ParsedOptions* Runtime::ParsedOptions::Create(const Options& options, bool ignore_unrecognized) {
   UniquePtr<ParsedOptions> parsed(new ParsedOptions());
   const char* boot_class_path_string = getenv("BOOTCLASSPATH");
@@ -543,17 +529,19 @@
   return parsed.release();
 }
 
-Runtime* Runtime::Create(const Options& options, bool ignore_unrecognized) {
+bool Runtime::Create(const Options& options, bool ignore_unrecognized) {
   // TODO: acquire a static mutex on Runtime to avoid racing.
   if (Runtime::instance_ != NULL) {
-    return NULL;
+    return false;
   }
+  GlobalSynchronization::Init();
   instance_ = new Runtime;
   if (!instance_->Init(options, ignore_unrecognized)) {
     delete instance_;
     instance_ = NULL;
+    return false;
   }
-  return instance_;
+  return true;
 }
 
 static void CreateSystemClassLoader() {
@@ -561,28 +549,28 @@
     return;
   }
 
-  ScopedJniThreadState ts(Thread::Current());
+  ScopedObjectAccess soa(Thread::Current());
 
-  Class* class_loader_class = ts.Decode<Class*>(WellKnownClasses::java_lang_ClassLoader);
+  Class* class_loader_class = soa.Decode<Class*>(WellKnownClasses::java_lang_ClassLoader);
   CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(class_loader_class, true, true));
 
   Method* getSystemClassLoader = class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
   CHECK(getSystemClassLoader != NULL);
 
   ClassLoader* class_loader =
-    down_cast<ClassLoader*>(InvokeWithJValues(ts, NULL, getSystemClassLoader, NULL).GetL());
+    down_cast<ClassLoader*>(InvokeWithJValues(soa, NULL, getSystemClassLoader, NULL).GetL());
   CHECK(class_loader != NULL);
 
-  ts.Self()->SetClassLoaderOverride(class_loader);
+  soa.Self()->SetClassLoaderOverride(class_loader);
 
-  Class* thread_class = ts.Decode<Class*>(WellKnownClasses::java_lang_Thread);
+  Class* thread_class = soa.Decode<Class*>(WellKnownClasses::java_lang_Thread);
   CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(thread_class, true, true));
 
   Field* contextClassLoader = thread_class->FindDeclaredInstanceField("contextClassLoader",
                                                                       "Ljava/lang/ClassLoader;");
   CHECK(contextClassLoader != NULL);
 
-  contextClassLoader->SetObject(ts.Self()->GetPeer(), class_loader);
+  contextClassLoader->SetObject(soa.Self()->GetPeer(), class_loader);
 }
 
 void Runtime::Start() {
@@ -593,16 +581,16 @@
   // Relocate the OatFiles (ELF images).
   class_linker_->RelocateExecutable();
 
-  // Restore main thread state to kNative as expected by native code.
-  Thread* self = Thread::Current();
-  self->SetState(kNative);
-
   // Pre-allocate an OutOfMemoryError for the double-OOME case.
+  Thread* self = Thread::Current();
   self->ThrowNewException("Ljava/lang/OutOfMemoryError;",
                           "OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack available");
   pre_allocated_OutOfMemoryError_ = self->GetException();
   self->ClearException();
 
+  // Restore main thread state to kNative as expected by native code.
+  self->TransitionFromRunnableToSuspended(kNative);
+
   started_ = true;
 
   // InitNativeMethods needs to be after started_ so that the classes
@@ -651,7 +639,10 @@
   Thread* self = Thread::Current();
 
   // Must be in the kNative state for calling native methods.
-  CHECK_EQ(self->GetState(), kNative);
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(self->GetState(), kNative);
+  }
 
   JNIEnv* env = self->GetJniEnv();
   env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, WellKnownClasses::java_lang_Daemons_start);
@@ -700,7 +691,8 @@
   heap_ = new Heap(options->heap_initial_size_,
                    options->heap_growth_limit_,
                    options->heap_maximum_size_,
-                   options->image_);
+                   options->image_,
+                   options->is_concurrent_gc_enabled_);
 
   BlockSignals();
   InitPlatformSignalHandlers();
@@ -714,7 +706,7 @@
   Thread::Attach("main", false, NULL);
 
   // Set us to runnable so tools using a runtime can allocate and GC by default
-  Thread::Current()->SetState(kRunnable);
+  Thread::Current()->TransitionFromSuspendedToRunnable();
 
   // Now we're attached, we can take the heap lock and validate the heap.
   GetHeap()->EnableObjectValidation();
@@ -747,7 +739,10 @@
   JNIEnv* env = self->GetJniEnv();
 
   // Must be in the kNative state for calling native methods (JNI_OnLoad code).
-  CHECK_EQ(self->GetState(), kNative);
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(self->GetState(), kNative);
+  }
 
   // First set up JniConstants, which is used by both the runtime's built-in native
   // methods and libcore.
@@ -760,7 +755,15 @@
   // Then set up libcore, which is just a regular JNI library with a regular JNI_OnLoad.
   // Most JNI libraries can just use System.loadLibrary, but libcore can't because it's
   // the library that implements System.loadLibrary!
-  LoadJniLibrary(instance_->GetJavaVM(), "javacore");
+  {
+    std::string mapped_name(StringPrintf(OS_SHARED_LIB_FORMAT_STR, "javacore"));
+    std::string reason;
+    self->TransitionFromSuspendedToRunnable();
+    if (!instance_->java_vm_->LoadNativeLibrary(mapped_name, NULL, reason)) {
+      LOG(FATAL) << "LoadNativeLibrary failed for \"" << mapped_name << "\": " << reason;
+    }
+    self->TransitionFromRunnableToSuspended(kNative);
+  }
   VLOG(startup) << "Runtime::InitNativeMethods exiting";
 }
 
@@ -826,12 +829,12 @@
 }
 
 void Runtime::DumpLockHolders(std::ostream& os) {
-  pid_t heap_lock_owner = GetHeap()->GetLockOwner();
+  uint64_t mutator_lock_owner = GlobalSynchronization::mutator_lock_->GetExclusiveOwnerTid();
   pid_t thread_list_lock_owner = GetThreadList()->GetLockOwner();
   pid_t classes_lock_owner = GetClassLinker()->GetClassesLockOwner();
   pid_t dex_lock_owner = GetClassLinker()->GetDexLockOwner();
-  if ((heap_lock_owner | thread_list_lock_owner | classes_lock_owner | dex_lock_owner) != 0) {
-    os << "Heap lock owner tid: " << heap_lock_owner << "\n"
+  if ((thread_list_lock_owner | classes_lock_owner | dex_lock_owner) != 0) {
+    os << "Mutator lock exclusive owner tid: " << mutator_lock_owner << "\n"
        << "ThreadList lock owner tid: " << thread_list_lock_owner << "\n"
        << "ClassLinker classes lock owner tid: " << classes_lock_owner << "\n"
        << "ClassLinker dex lock owner tid: " << dex_lock_owner << "\n";
@@ -913,7 +916,7 @@
   if (self->HasManagedStack()) {
     LOG(FATAL) << *Thread::Current() << " attempting to detach while still running code";
   }
-  thread_list_->Unregister();
+  thread_list_->Unregister(self);
 }
 
 void Runtime::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
@@ -1031,7 +1034,7 @@
   tracer_ = NULL;
 }
 
-const std::vector<const DexFile*>& Runtime::GetCompileTimeClassPath(const ClassLoader* class_loader) {
+const std::vector<const DexFile*>& Runtime::GetCompileTimeClassPath(jobject class_loader) {
   if (class_loader == NULL) {
     return GetClassLinker()->GetBootClassPath();
   }
@@ -1041,7 +1044,7 @@
   return it->second;
 }
 
-void Runtime::SetCompileTimeClassPath(const ClassLoader* class_loader, std::vector<const DexFile*>& class_path) {
+void Runtime::SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path) {
   CHECK(!IsStarted());
   use_compile_time_class_path_ = true;
   compile_time_class_paths_.Put(class_loader, class_path);
diff --git a/src/runtime.h b/src/runtime.h
index 544dcf4..3b9919c 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -28,6 +28,7 @@
 #include "globals.h"
 #include "heap.h"
 #include "instruction_set.h"
+#include "jobject_comparator.h"
 #include "macros.h"
 #include "runtime_stats.h"
 #include "safe_map.h"
@@ -95,7 +96,8 @@
   };
 
   // Creates and initializes a new runtime.
-  static Runtime* Create(const Options& options, bool ignore_unrecognized);
+  static bool Create(const Options& options, bool ignore_unrecognized)
+      SHARED_TRYLOCK_FUNCTION(true, GlobalSynchronization::mutator_lock_);
 
   bool IsCompiler() const {
     return is_compiler_;
@@ -115,7 +117,7 @@
   }
 
   // Starts a runtime, which may cause threads to be started and code to run.
-  void Start();
+  void Start() UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_);
 
   bool IsShuttingDown() const {
     return shutting_down_;
@@ -138,7 +140,7 @@
   // This isn't marked ((noreturn)) because then gcc will merge multiple calls
   // in a single function together. This reduces code size slightly, but means
   // that the native stack trace we get may point at the wrong call site.
-  static void Abort();
+  static void Abort() LOCKS_EXCLUDED(GlobalSynchronization::abort_lock_);
 
   // Returns the "main" ThreadGroup, used when attaching user threads.
   jobject GetMainThreadGroup() const;
@@ -152,9 +154,10 @@
   void CallExitHook(jint status);
 
   // Detaches the current native thread from the runtime.
-  void DetachCurrentThread();
+  void DetachCurrentThread() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
 
-  void DumpForSigQuit(std::ostream& os);
+  void DumpForSigQuit(std::ostream& os)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void DumpLockHolders(std::ostream& os);
 
   ~Runtime();
@@ -207,7 +210,8 @@
     return "2.0.0";
   }
 
-  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
+  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool HasJniDlsymLookupStub() const {
     return jni_stub_array_ != NULL;
@@ -263,7 +267,7 @@
     resolution_method_ = method;
   }
 
-  Method* CreateResolutionMethod();
+  Method* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Returns a special method that describes all callee saves being spilled to the stack.
   enum CalleeSaveType {
@@ -284,10 +288,14 @@
 
   void SetCalleeSaveMethod(Method* method, CalleeSaveType type);
 
-  Method* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type);
+  Method* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set);
-  Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set);
+  Method* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+  Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   int32_t GetStat(int kind);
 
@@ -322,8 +330,8 @@
     return use_compile_time_class_path_;
   }
 
-  const std::vector<const DexFile*>& GetCompileTimeClassPath(const ClassLoader* class_loader);
-  void SetCompileTimeClassPath(const ClassLoader* class_loader, std::vector<const DexFile*>& class_path);
+  const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
+  void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
 
  private:
   static void InitPlatformSignalHandlers();
@@ -332,8 +340,9 @@
 
   void BlockSignals();
 
-  bool Init(const Options& options, bool ignore_unrecognized);
-  void InitNativeMethods();
+  bool Init(const Options& options, bool ignore_unrecognized)
+      SHARED_TRYLOCK_FUNCTION(true, GlobalSynchronization::mutator_lock_);
+  void InitNativeMethods() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_);
   void InitThreadGroups(Thread* self);
   void RegisterRuntimeNativeMethods(JNIEnv* env);
 
@@ -417,7 +426,7 @@
   size_t method_trace_file_size_;
   Trace* tracer_;
 
-  typedef SafeMap<const ClassLoader*, std::vector<const DexFile*> > CompileTimeClassPaths;
+  typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
   CompileTimeClassPaths compile_time_class_paths_;
   bool use_compile_time_class_path_;
 
diff --git a/src/runtime_linux.cc b/src/runtime_linux.cc
index a84dfc9..8365079 100644
--- a/src/runtime_linux.cc
+++ b/src/runtime_linux.cc
@@ -226,8 +226,7 @@
 };
 
 static void HandleUnexpectedSignal(int signal_number, siginfo_t* info, void* raw_context) {
-  static Mutex unexpected_signal_lock("unexpected signal lock");
-  MutexLock mu(unexpected_signal_lock);
+  MutexLock mu(*GlobalSynchronization::unexpected_signal_lock_);
 
   bool has_address = (signal_number == SIGILL || signal_number == SIGBUS ||
                       signal_number == SIGFPE || signal_number == SIGSEGV);
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index c067765..0caccf6 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -293,7 +293,8 @@
 }
 
 static std::string ClassNameFromIndex(const Method* method, uint32_t ref,
-                                      verifier::VerifyErrorRefType ref_type, bool access) {
+                                      verifier::VerifyErrorRefType ref_type, bool access)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
 
diff --git a/src/runtime_support.h b/src/runtime_support.h
index d96cab9..bba9161 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -44,37 +44,50 @@
 class Object;
 
 // Helpers to give consistent descriptive exception messages
-void ThrowNewIllegalAccessErrorClass(Thread* self, Class* referrer, Class* accessed);
+void ThrowNewIllegalAccessErrorClass(Thread* self, Class* referrer, Class* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 void ThrowNewIllegalAccessErrorClassForMethodDispatch(Thread* self, Class* referrer,
                                                       Class* accessed,
                                                       const Method* caller,
                                                       const Method* called,
-                                                      InvokeType type);
+                                                      InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 void ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(Thread* self,
                                                                    const Method* referrer,
                                                                    const Method* interface_method,
-                                                                   Object* this_object);
-void ThrowNewIllegalAccessErrorField(Thread* self, Class* referrer, Field* accessed);
-void ThrowNewIllegalAccessErrorFinalField(Thread* self, const Method* referrer, Field* accessed);
+                                                                   Object* this_object)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+void ThrowNewIllegalAccessErrorField(Thread* self, Class* referrer, Field* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+void ThrowNewIllegalAccessErrorFinalField(Thread* self, const Method* referrer, Field* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-void ThrowNewIllegalAccessErrorMethod(Thread* self, Class* referrer, Method* accessed);
-void ThrowNullPointerExceptionForFieldAccess(Thread* self, Field* field, bool is_read);
+void ThrowNewIllegalAccessErrorMethod(Thread* self, Class* referrer, Method* accessed)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+void ThrowNullPointerExceptionForFieldAccess(Thread* self, Field* field, bool is_read)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 void ThrowNullPointerExceptionForMethodAccess(Thread* self, Method* caller, uint32_t method_idx,
-                                              InvokeType type);
-void ThrowNullPointerExceptionFromDexPC(Thread* self, Method* caller, uint32_t dex_pc);
-void ThrowVerificationError(Thread* self, const Method* method, int32_t kind, int32_t ref);
+                                              InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+void ThrowNullPointerExceptionFromDexPC(Thread* self, Method* caller, uint32_t dex_pc)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+void ThrowVerificationError(Thread* self, const Method* method, int32_t kind, int32_t ref)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 std::string FieldNameFromIndex(const Method* method, uint32_t ref,
-                               verifier::VerifyErrorRefType ref_type, bool access);
+                               verifier::VerifyErrorRefType ref_type, bool access)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 std::string MethodNameFromIndex(const Method* method, uint32_t ref,
-                                verifier::VerifyErrorRefType ref_type, bool access);
+                                verifier::VerifyErrorRefType ref_type, bool access)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
 // cannot be resolved, throw an error. If it can, use it to create an instance.
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
 static inline Object* AllocObjectFromCode(uint32_t type_idx, Method* method, Thread* self,
-                                          bool access_check) {
+                                          bool access_check)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
   Runtime* runtime = Runtime::Current();
   if (UNLIKELY(klass == NULL)) {
@@ -108,7 +121,8 @@
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
 static inline Array* AllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
-                                        Thread* self, bool access_check) {
+                                        Thread* self, bool access_check)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (UNLIKELY(component_count < 0)) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d",
                                           component_count);
@@ -134,15 +148,18 @@
 }
 
 extern Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
-                                         Thread* self, bool access_check);
+                                         Thread* self, bool access_check)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 extern Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer, Thread* self,
                                 bool is_static, bool is_primitive, bool is_set,
-                                size_t expected_size);
+                                size_t expected_size)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Fast path field resolution that can't throw exceptions
 static inline Field* FindFieldFast(uint32_t field_idx, const Method* referrer, bool is_primitive,
-                                   size_t expected_size, bool is_set) {
+                                   size_t expected_size, bool is_set)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Field* resolved_field = referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
   if (UNLIKELY(resolved_field == NULL)) {
     return NULL;
@@ -170,7 +187,8 @@
 
 // Fast path method resolution that can't throw exceptions
 static inline Method* FindMethodFast(uint32_t method_idx, Object* this_object, const Method* referrer,
-                              bool access_check, InvokeType type) {
+                                     bool access_check, InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   bool is_direct = type == kStatic || type == kDirect;
   if (UNLIKELY(this_object == NULL && !is_direct)) {
     return NULL;
@@ -204,12 +222,15 @@
 }
 
 extern Method* FindMethodFromCode(uint32_t method_idx, Object* this_object, const Method* referrer,
-                                  Thread* self, bool access_check, InvokeType type);
+                                  Thread* self, bool access_check, InvokeType type)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 extern Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread* self,
-                                     bool can_run_clinit, bool verify_access);
+                                     bool can_run_clinit, bool verify_access)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-static inline String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx) {
+static inline String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
   return class_linker->ResolveString(string_idx, referrer);
 }
diff --git a/src/scoped_heap_lock.h b/src/scoped_heap_lock.h
deleted file mode 100644
index 0dee589..0000000
--- a/src/scoped_heap_lock.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ART_SRC_SCOPED_HEAP_LOCK_H_
-#define ART_SRC_SCOPED_HEAP_LOCK_H_
-
-#include "heap.h"
-#include "macros.h"
-#include "runtime.h"
-
-namespace art {
-
-class ScopedHeapLock {
- public:
-  ScopedHeapLock() {
-    Runtime::Current()->GetHeap()->Lock();
-  }
-
-  ~ScopedHeapLock() {
-    Runtime::Current()->GetHeap()->Unlock();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedHeapLock);
-};
-
-}  // namespace art
-
-#endif  // ART_SRC_SCOPED_HEAP_LOCK_H_
diff --git a/src/scoped_jni_thread_state.h b/src/scoped_jni_thread_state.h
deleted file mode 100644
index 1c9ab2c..0000000
--- a/src/scoped_jni_thread_state.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright (C) 2011 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 "casts.h"
-#include "jni_internal.h"
-#include "thread.h"
-
-namespace art {
-
-// Entry/exit processing for transitions from Native to Runnable (ie within JNI functions).
-//
-// This class performs the necessary thread state switching to and from Runnable and lets us
-// amortize the cost of working out the current thread. Additionally it lets us check (and repair)
-// apps that are using a JNIEnv on the wrong thread. The class also decodes and encodes Objects
-// into jobjects via methods of this class. Performing this here enforces the Runnable thread state
-// for use of Object, thereby inhibiting the Object being modified by GC whilst native or VM code
-// is also manipulating the Object.
-//
-// The destructor transitions back to the previous thread state, typically Native. In this case
-// GC and thread suspension may occur.
-class ScopedJniThreadState {
- public:
-  explicit ScopedJniThreadState(JNIEnv* env, ThreadState new_state = kRunnable)
-      : env_(reinterpret_cast<JNIEnvExt*>(env)), vm_(env_->vm), self_(ThreadForEnv(env)),
-        old_thread_state_(self_->SetState(new_state)), thread_state_(new_state) {
-    self_->VerifyStack();
-  }
-
-  explicit ScopedJniThreadState(Thread* self, ThreadState new_state = kRunnable)
-      : env_(reinterpret_cast<JNIEnvExt*>(self->GetJniEnv())), vm_(env_->vm), self_(self),
-        old_thread_state_(self_->SetState(new_state)), thread_state_(new_state) {
-    if (!Vm()->work_around_app_jni_bugs && self != Thread::Current()) {
-      UnexpectedThreads(self, Thread::Current());
-    }
-    self_->VerifyStack();
-  }
-
-  // Used when we want a scoped JNI thread state but have no thread/JNIEnv.
-  explicit ScopedJniThreadState(JavaVM* vm)
-      : env_(NULL), vm_(reinterpret_cast<JavaVMExt*>(vm)), self_(NULL),
-        old_thread_state_(kTerminated), thread_state_(kTerminated) {}
-
-  ~ScopedJniThreadState() {
-    if (self_ != NULL) {
-      self_->SetState(old_thread_state_);
-    }
-  }
-
-  JNIEnvExt* Env() const {
-    return env_;
-  }
-
-  Thread* Self() const {
-    return self_;
-  }
-
-  JavaVMExt* Vm() const {
-    return vm_;
-  }
-
-  /*
-   * Add a local reference for an object to the indirect reference table associated with the
-   * current stack frame.  When the native function returns, the reference will be discarded.
-   * Part of the ScopedJniThreadState as native code shouldn't be working on raw Object* without
-   * having transitioned its state.
-   *
-   * We need to allow the same reference to be added multiple times.
-   *
-   * This will be called on otherwise unreferenced objects.  We cannot do GC allocations here, and
-   * it's best if we don't grab a mutex.
-   *
-   * Returns the local reference (currently just the same pointer that was
-   * passed in), or NULL on failure.
-   */
-  template<typename T>
-  T AddLocalReference(Object* obj) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-    if (obj == NULL) {
-      return NULL;
-    }
-
-    DCHECK_NE((reinterpret_cast<uintptr_t>(obj) & 0xffff0000), 0xebad0000);
-
-    IndirectReferenceTable& locals = Env()->locals;
-
-    uint32_t cookie = Env()->local_ref_cookie;
-    IndirectRef ref = locals.Add(cookie, obj);
-
-  #if 0 // TODO: fix this to understand PushLocalFrame, so we can turn it on.
-    if (Env()->check_jni) {
-      size_t entry_count = locals.Capacity();
-      if (entry_count > 16) {
-        LOG(WARNING) << "Warning: more than 16 JNI local references: "
-                     << entry_count << " (most recent was a " << PrettyTypeOf(obj) << ")\n"
-                     << Dumpable<IndirectReferenceTable>(locals);
-        // TODO: LOG(FATAL) in a later release?
-      }
-    }
-  #endif
-
-    if (Vm()->work_around_app_jni_bugs) {
-      // Hand out direct pointers to support broken old apps.
-      return reinterpret_cast<T>(obj);
-    }
-
-    return reinterpret_cast<T>(ref);
-  }
-
-  template<typename T>
-  T Decode(jobject obj) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-    return down_cast<T>(Self()->DecodeJObject(obj));
-  }
-
-  Field* DecodeField(jfieldID fid) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-  #ifdef MOVING_GARBAGE_COLLECTOR
-    // TODO: we should make these unique weak globals if Field instances can ever move.
-    UNIMPLEMENTED(WARNING);
-  #endif
-    return reinterpret_cast<Field*>(fid);
-  }
-
-  jfieldID EncodeField(Field* field) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-  #ifdef MOVING_GARBAGE_COLLECTOR
-    UNIMPLEMENTED(WARNING);
-  #endif
-    return reinterpret_cast<jfieldID>(field);
-  }
-
-  Method* DecodeMethod(jmethodID mid) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-  #ifdef MOVING_GARBAGE_COLLECTOR
-    // TODO: we should make these unique weak globals if Method instances can ever move.
-    UNIMPLEMENTED(WARNING);
-  #endif
-    return reinterpret_cast<Method*>(mid);
-  }
-
-  jmethodID EncodeMethod(Method* method) const {
-    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
-  #ifdef MOVING_GARBAGE_COLLECTOR
-    UNIMPLEMENTED(WARNING);
-  #endif
-    return reinterpret_cast<jmethodID>(method);
-  }
-
- private:
-  static Thread* ThreadForEnv(JNIEnv* env) {
-    JNIEnvExt* full_env(reinterpret_cast<JNIEnvExt*>(env));
-    bool work_around_app_jni_bugs = full_env->vm->work_around_app_jni_bugs;
-    Thread* env_self = full_env->self;
-    Thread* self = work_around_app_jni_bugs ? Thread::Current() : env_self;
-    if (!work_around_app_jni_bugs && self != env_self) {
-      UnexpectedThreads(env_self, self);
-    }
-    return self;
-  }
-
-  static void UnexpectedThreads(Thread* found_self, Thread* expected_self) {
-    // TODO: pass through function name so we can use it here instead of NULL...
-    JniAbortF(NULL, "JNIEnv for %s used on %s",
-             found_self != NULL ? ToStr<Thread>(*found_self).c_str() : "NULL",
-             expected_self != NULL ? ToStr<Thread>(*expected_self).c_str() : "NULL");
-
-  }
-
-  // The full JNIEnv.
-  JNIEnvExt* const env_;
-  // The full JavaVM.
-  JavaVMExt* const vm_;
-  // Cached current thread derived from the JNIEnv.
-  Thread* const self_;
-  // Previous thread state, most likely kNative.
-  const ThreadState old_thread_state_;
-  // Local cache of thread state to enable quick sanity checks.
-  const ThreadState thread_state_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedJniThreadState);
-};
-
-}  // namespace art
diff --git a/src/scoped_thread_list_lock.cc b/src/scoped_thread_list_lock.cc
deleted file mode 100644
index 269c97e..0000000
--- a/src/scoped_thread_list_lock.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * 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 "scoped_thread_list_lock.h"
-
-#include "runtime.h"
-#include "thread_list.h"
-
-namespace art {
-
-ScopedThreadListLock::ScopedThreadListLock() {
-  // Avoid deadlock between two threads trying to SuspendAll
-  // simultaneously by going to kVmWait if the lock cannot be
-  // immediately acquired.
-  ThreadList* thread_list = Runtime::Current()->GetThreadList();
-  if (!thread_list->thread_list_lock_.TryLock()) {
-    Thread* self = Thread::Current();
-    if (self == NULL) {
-      // Self may be null during shutdown, but in that case there's no point going to kVmWait.
-      thread_list->thread_list_lock_.Lock();
-    } else {
-      ThreadState old_thread_state = self->SetState(kVmWait);
-      thread_list->thread_list_lock_.Lock();
-      // If we have the lock, by definition there's no GC in progress (though we
-      // might be taking the lock in order to start one). We avoid the suspend
-      // check here so we don't risk going to sleep on the thread suspend count lock
-      // while holding the thread list lock.
-      self->SetStateWithoutSuspendCheck(old_thread_state);
-    }
-  }
-}
-
-ScopedThreadListLock::~ScopedThreadListLock() {
-  Runtime::Current()->GetThreadList()->thread_list_lock_.Unlock();
-}
-
-}  // namespace art
diff --git a/src/scoped_thread_list_lock_releaser.cc b/src/scoped_thread_list_lock_releaser.cc
deleted file mode 100644
index d15eae5..0000000
--- a/src/scoped_thread_list_lock_releaser.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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 "scoped_thread_list_lock_releaser.h"
-
-#include "runtime.h"
-#include "thread_list.h"
-
-namespace art {
-
-ScopedThreadListLockReleaser::ScopedThreadListLockReleaser() : unlocked_(false) {
-  if (Thread::Current() == NULL) {
-    CHECK(Runtime::Current()->IsShuttingDown());
-    return;
-  }
-
-  if (Thread::Current()->held_mutexes_[kThreadListLock] > 0) {
-    Runtime::Current()->GetThreadList()->thread_list_lock_.Unlock();
-    unlocked_ = true;
-  }
-}
-
-ScopedThreadListLockReleaser::~ScopedThreadListLockReleaser() {
-  if (unlocked_) {
-    Runtime::Current()->GetThreadList()->thread_list_lock_.Lock();
-  }
-}
-
-}  // namespace art
diff --git a/src/scoped_thread_list_lock_releaser.h b/src/scoped_thread_list_lock_releaser.h
deleted file mode 100644
index af656d5..0000000
--- a/src/scoped_thread_list_lock_releaser.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ART_SRC_SCOPED_THREAD_LIST_LOCK_RELEASER_H_
-#define ART_SRC_SCOPED_THREAD_LIST_LOCK_RELEASER_H_
-
-#include "macros.h"
-
-namespace art {
-
-class ScopedThreadListLockReleaser {
- public:
-  ScopedThreadListLockReleaser();
-  ~ScopedThreadListLockReleaser();
-
- private:
-  // Whether or not we unlocked the thread list lock.
-  bool unlocked_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedThreadListLockReleaser);
-};
-
-}  // namespace art
-
-#endif  // ART_SRC_SCOPED_THREAD_LIST_LOCK_RELEASER_H_
diff --git a/src/scoped_thread_state_change.h b/src/scoped_thread_state_change.h
new file mode 100644
index 0000000..745e2d6
--- /dev/null
+++ b/src/scoped_thread_state_change.h
@@ -0,0 +1,315 @@
+/*
+ * 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.
+ */
+
+#ifndef ART_SRC_SCOPED_THREAD_STATE_CHANGE_H_
+#define ART_SRC_SCOPED_THREAD_STATE_CHANGE_H_
+
+#include "casts.h"
+#include "thread.h"
+
+namespace art {
+
+// Scoped change into and out of a particular state. Handles Runnable transitions that require
+// more complicated suspension checking. The subclasses ScopedObjectAccessUnchecked and
+// ScopedObjectAccess are used to handle the change into Runnable to get direct access to objects,
+// the unchecked variant doesn't aid annotalysis.
+class ScopedThreadStateChange {
+ public:
+  ScopedThreadStateChange(Thread* self, ThreadState new_thread_state)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      : self_(self), thread_state_(new_thread_state), expected_has_no_thread_(false) {
+    if (self_ == NULL) {
+      // Value chosen arbitrarily and won't be used in the destructor since thread_ == NULL.
+      old_thread_state_ = kTerminated;
+      CHECK(!Runtime::Current()->IsStarted() || Runtime::Current()->IsShuttingDown());
+    } else {
+      bool runnable_transition;
+      {
+        MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+        old_thread_state_ = self->GetState();
+        runnable_transition = old_thread_state_ == kRunnable || new_thread_state == kRunnable;
+        if (!runnable_transition) {
+          self_->SetState(new_thread_state);
+        }
+      }
+      if (runnable_transition && old_thread_state_ != new_thread_state) {
+        if (new_thread_state == kRunnable) {
+          self_->TransitionFromSuspendedToRunnable();
+        } else {
+          DCHECK_EQ(old_thread_state_, kRunnable);
+          self_->TransitionFromRunnableToSuspended(new_thread_state);
+        }
+      }
+    }
+  }
+
+  ~ScopedThreadStateChange() LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_) {
+    if (self_ == NULL) {
+      if (!expected_has_no_thread_) {
+        CHECK(Runtime::Current()->IsShuttingDown());
+      }
+    } else {
+      if (old_thread_state_ != thread_state_) {
+        if (old_thread_state_ == kRunnable) {
+          self_->TransitionFromSuspendedToRunnable();
+        } else if (thread_state_ == kRunnable) {
+          self_->TransitionFromRunnableToSuspended(old_thread_state_);
+        } else {
+          MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+          self_->SetState(old_thread_state_);
+        }
+      }
+    }
+  }
+
+  Thread* Self() const {
+    return self_;
+  }
+
+ protected:
+  // Constructor used by ScopedJniThreadState for an unattached thread that has access to the VM*.
+  ScopedThreadStateChange()
+      : self_(NULL), thread_state_(kTerminated), old_thread_state_(kTerminated),
+        expected_has_no_thread_(true) {}
+
+  Thread* const self_;
+  const ThreadState thread_state_;
+
+ private:
+  ThreadState old_thread_state_;
+  const bool expected_has_no_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedThreadStateChange);
+};
+
+// Entry/exit processing for transitions from Native to Runnable (ie within JNI functions).
+//
+// This class performs the necessary thread state switching to and from Runnable and lets us
+// amortize the cost of working out the current thread. Additionally it lets us check (and repair)
+// apps that are using a JNIEnv on the wrong thread. The class also decodes and encodes Objects
+// into jobjects via methods of this class. Performing this here enforces the Runnable thread state
+// for use of Object, thereby inhibiting the Object being modified by GC whilst native or VM code
+// is also manipulating the Object.
+//
+// The destructor transitions back to the previous thread state, typically Native. In this state
+// GC and thread suspension may occur.
+//
+// For annotalysis the subclass ScopedObjectAccess (below) makes it explicit that a shared of
+// the mutator_lock_ will be acquired on construction.
+class ScopedObjectAccessUnchecked : public ScopedThreadStateChange {
+ public:
+  explicit ScopedObjectAccessUnchecked(JNIEnv* env)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      : ScopedThreadStateChange(ThreadForEnv(env), kRunnable),
+        env_(reinterpret_cast<JNIEnvExt*>(env)), vm_(env_->vm) {
+    self_->VerifyStack();
+  }
+
+  explicit ScopedObjectAccessUnchecked(Thread* self)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      : ScopedThreadStateChange(self, kRunnable),
+        env_(reinterpret_cast<JNIEnvExt*>(self->GetJniEnv())),
+        vm_(env_ != NULL ? env_->vm : NULL) {
+    if (Vm() != NULL && !Vm()->work_around_app_jni_bugs && self != Thread::Current()) {
+      UnexpectedThreads(self, Thread::Current());
+    }
+    self_->VerifyStack();
+  }
+
+  // Used when we want a scoped JNI thread state but have no thread/JNIEnv. Consequently doesn't
+  // change into Runnable or acquire a share on the mutator_lock_.
+  explicit ScopedObjectAccessUnchecked(JavaVM* vm)
+      : ScopedThreadStateChange(), env_(NULL), vm_(reinterpret_cast<JavaVMExt*>(vm)) {}
+
+  JNIEnvExt* Env() const {
+    return env_;
+  }
+
+  JavaVMExt* Vm() const {
+    return vm_;
+  }
+
+  /*
+   * Add a local reference for an object to the indirect reference table associated with the
+   * current stack frame.  When the native function returns, the reference will be discarded.
+   * Part of the ScopedJniThreadState as native code shouldn't be working on raw Object* without
+   * having transitioned its state.
+   *
+   * We need to allow the same reference to be added multiple times.
+   *
+   * This will be called on otherwise unreferenced objects.  We cannot do GC allocations here, and
+   * it's best if we don't grab a mutex.
+   *
+   * Returns the local reference (currently just the same pointer that was
+   * passed in), or NULL on failure.
+   */
+  template<typename T>
+  T AddLocalReference(Object* obj) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+    if (obj == NULL) {
+      return NULL;
+    }
+
+    DCHECK_NE((reinterpret_cast<uintptr_t>(obj) & 0xffff0000), 0xebad0000);
+
+    IndirectReferenceTable& locals = Env()->locals;
+
+    uint32_t cookie = Env()->local_ref_cookie;
+    IndirectRef ref = locals.Add(cookie, obj);
+
+#if 0 // TODO: fix this to understand PushLocalFrame, so we can turn it on.
+    if (Env()->check_jni) {
+      size_t entry_count = locals.Capacity();
+      if (entry_count > 16) {
+        LOG(WARNING) << "Warning: more than 16 JNI local references: "
+                     << entry_count << " (most recent was a " << PrettyTypeOf(obj) << ")\n"
+                     << Dumpable<IndirectReferenceTable>(locals);
+        // TODO: LOG(FATAL) in a later release?
+      }
+    }
+#endif
+
+    if (Vm()->work_around_app_jni_bugs) {
+      // Hand out direct pointers to support broken old apps.
+      return reinterpret_cast<T>(obj);
+    }
+
+    return reinterpret_cast<T>(ref);
+  }
+
+  template<typename T>
+  T Decode(jobject obj) const
+      LOCKS_EXCLUDED(JavaVMExt::globals_lock,
+                     JavaVMExt::weak_globals_lock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+    return down_cast<T>(Self()->DecodeJObject(obj));
+  }
+
+  Field* DecodeField(jfieldID fid) const
+      LOCKS_EXCLUDED(JavaVMExt::globals_lock,
+                     JavaVMExt::weak_globals_lock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+#ifdef MOVING_GARBAGE_COLLECTOR
+    // TODO: we should make these unique weak globals if Field instances can ever move.
+    UNIMPLEMENTED(WARNING);
+#endif
+    return reinterpret_cast<Field*>(fid);
+  }
+
+  jfieldID EncodeField(Field* field) const
+      LOCKS_EXCLUDED(JavaVMExt::globals_lock,
+                     JavaVMExt::weak_globals_lock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+#ifdef MOVING_GARBAGE_COLLECTOR
+    UNIMPLEMENTED(WARNING);
+#endif
+    return reinterpret_cast<jfieldID>(field);
+  }
+
+  Method* DecodeMethod(jmethodID mid) const
+      LOCKS_EXCLUDED(JavaVMExt::globals_lock,
+                     JavaVMExt::weak_globals_lock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+#ifdef MOVING_GARBAGE_COLLECTOR
+    // TODO: we should make these unique weak globals if Method instances can ever move.
+    UNIMPLEMENTED(WARNING);
+#endif
+    return reinterpret_cast<Method*>(mid);
+  }
+
+  jmethodID EncodeMethod(Method* method) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    DCHECK_EQ(thread_state_, kRunnable);  // Don't work with raw objects in non-runnable states.
+#ifdef MOVING_GARBAGE_COLLECTOR
+    UNIMPLEMENTED(WARNING);
+#endif
+    return reinterpret_cast<jmethodID>(method);
+  }
+
+ private:
+  static Thread* ThreadForEnv(JNIEnv* env) {
+    JNIEnvExt* full_env(reinterpret_cast<JNIEnvExt*>(env));
+    bool work_around_app_jni_bugs = full_env->vm->work_around_app_jni_bugs;
+    Thread* env_self = full_env->self;
+    Thread* self = work_around_app_jni_bugs ? Thread::Current() : env_self;
+    if (!work_around_app_jni_bugs && self != env_self) {
+      UnexpectedThreads(env_self, self);
+    }
+    return self;
+  }
+
+  static void UnexpectedThreads(Thread* found_self, Thread* expected_self) {
+    // TODO: pass through function name so we can use it here instead of NULL...
+    JniAbortF(NULL, "JNIEnv for %s used on %s",
+             found_self != NULL ? ToStr<Thread>(*found_self).c_str() : "NULL",
+             expected_self != NULL ? ToStr<Thread>(*expected_self).c_str() : "NULL");
+
+  }
+
+  // The full JNIEnv.
+  JNIEnvExt* const env_;
+  // The full JavaVM.
+  JavaVMExt* const vm_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedObjectAccessUnchecked);
+};
+
+// Annotalysis helping variant of the above.
+class ScopedObjectAccess : public ScopedObjectAccessUnchecked {
+ public:
+  explicit ScopedObjectAccess(JNIEnv* env)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      : ScopedObjectAccessUnchecked(env) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+  }
+
+  explicit ScopedObjectAccess(Thread* self)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      : ScopedObjectAccessUnchecked(self) {
+    GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+  }
+
+  ~ScopedObjectAccess() UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_) {
+    // Base class will release share of lock. Invoked after this destructor.
+  }
+
+ private:
+  // TODO: remove this constructor. It is used by check JNI's ScopedCheck to make it believe that
+  //       routines operating with just a VM are sound, they are not, but when you have just a VM
+  //       you cannot call the unsound routines.
+  explicit ScopedObjectAccess(JavaVM* vm)
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      : ScopedObjectAccessUnchecked(vm) {}
+
+  friend class ScopedCheck;
+  DISALLOW_COPY_AND_ASSIGN(ScopedObjectAccess);
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_SCOPED_THREAD_STATE_CHANGE_H_
diff --git a/src/signal_catcher.cc b/src/signal_catcher.cc
index 919923e..156aec6 100644
--- a/src/signal_catcher.cc
+++ b/src/signal_catcher.cc
@@ -30,7 +30,7 @@
 #include "heap.h"
 #include "os.h"
 #include "runtime.h"
-#include "scoped_heap_lock.h"
+#include "scoped_thread_state_change.h"
 #include "signal_set.h"
 #include "thread.h"
 #include "thread_list.h"
@@ -99,7 +99,7 @@
     return;
   }
 
-  ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
+  ScopedThreadStateChange tsc(Thread::Current(), kWaitingForSignalCatcherOutput);
   int fd = open(stack_trace_file_.c_str(), O_APPEND | O_CREAT | O_WRONLY, 0666);
   if (fd == -1) {
     PLOG(ERROR) << "Unable to open stack trace file '" << stack_trace_file_ << "'";
@@ -118,17 +118,27 @@
   Runtime* runtime = Runtime::Current();
   ThreadList* thread_list = runtime->GetThreadList();
 
-  // We take the heap lock before suspending all threads so we don't end up in a situation where
-  // one of the suspended threads suspended via the implicit FullSuspendCheck on the slow path of
-  // Heap::Lock, which is the only case where a thread can be suspended while holding the heap lock.
-  // (We need the heap lock when we dump the thread list. We could probably fix this by duplicating
-  // more state from java.lang.Thread in struct Thread.)
-  ScopedHeapLock heap_lock;
   thread_list->SuspendAll();
 
+  // We should exclusively hold the mutator lock, set state to Runnable without a pending
+  // suspension to avoid giving away or trying re-acquire the mutator lock.
+  GlobalSynchronization::mutator_lock_->AssertExclusiveHeld();
+  Thread* self = Thread::Current();
+  ThreadState old_state;
+  int suspend_count;
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    suspend_count = self->GetSuspendCount();
+    if (suspend_count != 0) {
+      CHECK_EQ(suspend_count, 1);
+      self->ModifySuspendCount(-1, false);
+    }
+    old_state = self->SetState(kRunnable);
+  }
+
   std::ostringstream os;
   os << "\n"
-     << "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n";
+      << "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n";
 
   DumpCmdLine(os);
 
@@ -144,7 +154,13 @@
   }
 
   os << "----- end " << getpid() << " -----\n";
-
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    self->SetState(old_state);
+    if (suspend_count != 0) {
+      self->ModifySuspendCount(+1, false);
+    }
+  }
   thread_list->ResumeAll();
 
   Output(os.str());
@@ -156,7 +172,7 @@
 }
 
 int SignalCatcher::WaitForSignal(Thread* self, SignalSet& signals) {
-  ScopedThreadStateChange tsc(self, kVmWait);
+  ScopedThreadStateChange tsc(self, kWaitingInMainSignalCatcherLoop);
 
   // Signals for sigwait() must be blocked but not ignored.  We
   // block signals like SIGQUIT for all threads, so the condition
@@ -183,7 +199,6 @@
   runtime->AttachCurrentThread("Signal Catcher", true, runtime->GetSystemThreadGroup());
 
   Thread* self = Thread::Current();
-  self->SetState(kRunnable);
 
   {
     MutexLock mu(signal_catcher->lock_);
diff --git a/src/signal_catcher.h b/src/signal_catcher.h
index 35e035f..11a2c09 100644
--- a/src/signal_catcher.h
+++ b/src/signal_catcher.h
@@ -35,7 +35,10 @@
   explicit SignalCatcher(const std::string& stack_trace_file);
   ~SignalCatcher();
 
-  void HandleSigQuit();
+  void HandleSigQuit() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                                      GlobalSynchronization::thread_list_lock_,
+                                      GlobalSynchronization::thread_suspend_count_lock_);
+
 
  private:
   static void* Run(void* arg);
diff --git a/src/space.cc b/src/space.cc
index 02230e1..a828d91 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -45,7 +45,8 @@
 
 AllocSpace::AllocSpace(const std::string& name, MemMap* mem_map, void* mspace, byte* begin, byte* end,
                        size_t growth_limit)
-    : Space(name, mem_map, begin, end, GCRP_ALWAYS_COLLECT), mspace_(mspace), growth_limit_(growth_limit) {
+    : Space(name, mem_map, begin, end, GCRP_ALWAYS_COLLECT), lock_("allocation space lock"),
+      mspace_(mspace), growth_limit_(growth_limit) {
   CHECK(mspace != NULL);
 
   size_t bitmap_index = bitmap_index_++;
@@ -155,29 +156,37 @@
   mark_bitmap_.reset(temp_live_bitmap);
 }
 
-Object* AllocSpace::AllocWithoutGrowth(size_t num_bytes) {
+Object* AllocSpace::AllocWithoutGrowthLocked(size_t num_bytes) {
   Object* result = reinterpret_cast<Object*>(mspace_calloc(mspace_, 1, num_bytes));
 #if DEBUG_SPACES
   if (result != NULL) {
     CHECK(Contains(result)) << "Allocation (" << reinterpret_cast<void*>(result)
-        << ") not in bounds of heap " << *this;
+        << ") not in bounds of allocation space " << *this;
   }
 #endif
   return result;
 }
 
+Object* AllocSpace::AllocWithoutGrowth(size_t num_bytes) {
+  MutexLock mu(lock_);
+  return AllocWithoutGrowthLocked(num_bytes);
+}
+
 Object* AllocSpace::AllocWithGrowth(size_t num_bytes) {
+  MutexLock mu(lock_);
   // Grow as much as possible within the mspace.
   size_t max_allowed = Capacity();
   mspace_set_footprint_limit(mspace_, max_allowed);
   // Try the allocation.
-  void* ptr = AllocWithoutGrowth(num_bytes);
+  void* ptr = AllocWithoutGrowthLocked(num_bytes);
   // Shrink back down as small as possible.
   size_t footprint = mspace_footprint(mspace_);
   mspace_set_footprint_limit(mspace_, footprint);
   // Return the new allocation or NULL.
   Object* result = reinterpret_cast<Object*>(ptr);
+#if DEBUG_SPACES
   CHECK(result == NULL || Contains(result));
+#endif
   return result;
 }
 
@@ -228,6 +237,7 @@
 }
 
 void AllocSpace::Free(Object* ptr) {
+  MutexLock mu(lock_);
 #if DEBUG_SPACES
   CHECK(ptr != NULL);
   CHECK(Contains(ptr)) << "Free (" << ptr << ") not in bounds of heap " << *this;
@@ -236,6 +246,7 @@
 }
 
 void AllocSpace::FreeList(size_t num_ptrs, Object** ptrs) {
+  MutexLock mu(lock_);
 #if DEBUG_SPACES
   CHECK(ptrs != NULL);
   size_t num_broken_ptrs = 0;
@@ -275,6 +286,7 @@
 }
 
 void* AllocSpace::MoreCore(intptr_t increment) {
+  lock_.AssertHeld();
   byte* original_end = end_;
   if (increment != 0) {
     VLOG(heap) << "AllocSpace::MoreCore " << PrettySize(increment);
@@ -330,6 +342,7 @@
 }
 
 void AllocSpace::Trim() {
+  MutexLock mu(lock_);
   // Trim to release memory at the end of the space.
   mspace_trim(mspace_, 0);
   // Visit space looking for page-sized holes to advise the kernel we don't need.
@@ -338,14 +351,17 @@
 
 void AllocSpace::Walk(void(*callback)(void *start, void *end, size_t num_bytes, void* callback_arg),
                       void* arg) {
+  MutexLock mu(lock_);
   mspace_inspect_all(mspace_, callback, arg);
 }
 
 size_t AllocSpace::GetFootprintLimit() {
+  MutexLock mu(lock_);
   return mspace_footprint_limit(mspace_);
 }
 
 void AllocSpace::SetFootprintLimit(size_t new_size) {
+  MutexLock mu(lock_);
   VLOG(heap) << "AllocSpace::SetFootprintLimit " << PrettySize(new_size);
   // Compare against the actual footprint, rather than the Size(), because the heap may not have
   // grown all the way to the allowed size yet.
diff --git a/src/space.h b/src/space.h
index 1aeb33e..6ab3302 100644
--- a/src/space.h
+++ b/src/space.h
@@ -52,7 +52,8 @@
                                       byte* requested_begin);
 
   // create a Space from an image file. cannot be used for future allocation or collected.
-  static ImageSpace* CreateImageSpace(const std::string& image);
+  static ImageSpace* CreateImageSpace(const std::string& image)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   virtual ~Space() {}
 
@@ -122,7 +123,8 @@
   }
 
  protected:
-  Space(const std::string& name, MemMap* mem_map, byte* begin, byte* end, GcRetentionPolicy gc_retention_policy)
+  Space(const std::string& name, MemMap* mem_map, byte* begin, byte* end,
+        GcRetentionPolicy gc_retention_policy)
       : name_(name),
         mem_map_(mem_map),
         begin_(begin),
@@ -229,6 +231,8 @@
   AllocSpace* CreateZygoteSpace();
 
  private:
+  Object* AllocWithoutGrowthLocked(size_t num_bytes) EXCLUSIVE_LOCKS_REQUIRED(lock_);
+
   friend class Space;
 
   UniquePtr<SpaceBitmap> live_bitmap_;
@@ -245,6 +249,9 @@
   // The boundary tag overhead.
   static const size_t kChunkOverhead = kWordSize;
 
+  // Used to ensure mutual exclusion when the allocation spaces data structures are being modified.
+  Mutex lock_;
+
   // Underlying malloc space
   void* const mspace_;
 
@@ -272,7 +279,8 @@
   }
 
   // Mark the objects defined in this space in the given live bitmap
-  void RecordImageAllocations(SpaceBitmap* live_bitmap) const;
+  void RecordImageAllocations(SpaceBitmap* live_bitmap) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   virtual bool IsAllocSpace() const {
     return false;
diff --git a/src/space_bitmap.cc b/src/space_bitmap.cc
index 7da8146..438237d 100644
--- a/src/space_bitmap.cc
+++ b/src/space_bitmap.cc
@@ -225,7 +225,8 @@
 // Walk instance fields of the given Class. Separate function to allow recursion on the super
 // class.
 static void WalkInstanceFields(SpaceBitmap* visited, SpaceBitmap::Callback* callback, Object* obj,
-                               Class* klass, void* arg) {
+                               Class* klass, void* arg)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   // Visit fields of parent classes first.
   Class* super = klass->GetSuperClass();
   if (super != NULL) {
@@ -249,7 +250,8 @@
 
 // For an unvisited object, visit it then all its children found via fields.
 static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callback, Object* obj,
-                              void* arg) {
+                              void* arg)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   if (visited->Test(obj)) {
     return;
   }
diff --git a/src/space_bitmap.h b/src/space_bitmap.h
index adf1996..bbf60f3 100644
--- a/src/space_bitmap.h
+++ b/src/space_bitmap.h
@@ -111,7 +111,8 @@
   }
 
   template <typename Visitor>
-  void VisitMarkedRange(uintptr_t visit_begin, uintptr_t visit_end, const Visitor& visitor) const {
+  void VisitMarkedRange(uintptr_t visit_begin, uintptr_t visit_end, const Visitor& visitor) const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::heap_bitmap_lock_) {
     DCHECK_LT(visit_begin, visit_end);
 
     const size_t bit_index_start = (visit_begin - heap_begin_) / kAlignment;
@@ -177,7 +178,8 @@
 
   void Walk(Callback* callback, void* arg);
 
-  void InOrderWalk(Callback* callback, void* arg);
+  void InOrderWalk(Callback* callback, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void ScanWalk(uintptr_t base, uintptr_t max, ScanCallback* thunk, void* arg);
 
diff --git a/src/stack.cc b/src/stack.cc
index dd319bc..9795a77 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -24,37 +24,6 @@
 
 namespace art {
 
-class StackGetter {
- public:
-  StackGetter(const ScopedJniThreadState& ts, Thread* thread)
-      : ts_(ts), thread_(thread), trace_(NULL) {
-  }
-
-  static void Callback(void* arg) {
-    reinterpret_cast<StackGetter*>(arg)->Callback();
-  }
-
-  jobject GetTrace() {
-    return trace_;
-  }
-
- private:
-  void Callback() {
-    trace_ = thread_->CreateInternalStackTrace(ts_);
-  }
-
-  const ScopedJniThreadState& ts_;
-  Thread* const thread_;
-  jobject trace_;
-};
-
-jobject GetThreadStack(const ScopedJniThreadState& ts, Thread* thread) {
-  ThreadList* thread_list = Runtime::Current()->GetThreadList();
-  StackGetter stack_getter(ts, thread);
-  thread_list->RunWhileSuspended(thread, StackGetter::Callback, &stack_getter);
-  return stack_getter.GetTrace();
-}
-
 void ManagedStack::PushManagedStackFragment(ManagedStack* fragment) {
   // Copy this top fragment into given fragment.
   memcpy(fragment, this, sizeof(ManagedStack));
@@ -201,7 +170,7 @@
   return visitor.frames;
 }
 
-void StackVisitor::SanityCheckFrame() {
+void StackVisitor::SanityCheckFrame() const {
 #ifndef NDEBUG
   Method* method = GetMethod();
   CHECK(method->GetClass() == Method::GetMethodClass() ||
diff --git a/src/stack.h b/src/stack.h
index fb0bc48..578c631 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -32,11 +32,9 @@
 class Object;
 class ShadowFrame;
 class StackIndirectReferenceTable;
-class ScopedJniThreadState;
+class ScopedObjectAccess;
 class Thread;
 
-jobject GetThreadStack(const ScopedJniThreadState&, Thread*);
-
 class ShadowFrame {
  public:
   // Number of references contained within this shadow frame
@@ -217,6 +215,7 @@
  protected:
   StackVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
                Context* context)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : stack_start_(stack), trace_stack_(trace_stack), cur_shadow_frame_(NULL),
         cur_quick_frame_(NULL), cur_quick_frame_pc_(0), num_frames_(0), cur_depth_(0),
         context_(context) {}
@@ -225,9 +224,10 @@
   virtual ~StackVisitor() {}
 
   // Return 'true' if we should continue to visit more frames, 'false' to stop.
-  virtual bool VisitFrame() = 0;
+  virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) = 0;
 
-  void WalkStack(bool include_transitions = false);
+  void WalkStack(bool include_transitions = false)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Method* GetMethod() const {
     if (cur_shadow_frame_ != NULL) {
@@ -255,28 +255,30 @@
     return *reinterpret_cast<uintptr_t*>(save_addr);
   }
 
-  uint32_t GetDexPc() const;
+  uint32_t GetDexPc() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Returns the height of the stack in the managed stack frames, including transitions.
-  size_t GetFrameHeight() {
+  size_t GetFrameHeight() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetNumFrames() - cur_depth_;
   }
 
   // Returns a frame ID for JDWP use, starting from 1.
-  size_t GetFrameId() {
+  size_t GetFrameId() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return GetFrameHeight() + 1;
   }
 
-  size_t GetNumFrames() {
+  size_t GetNumFrames() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (num_frames_ == 0) {
       num_frames_ = ComputeNumFrames();
     }
     return num_frames_;
   }
 
-  uint32_t GetVReg(Method* m, int vreg) const;
+  uint32_t GetVReg(Method* m, int vreg) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void SetVReg(Method* m, int vreg, uint32_t new_value);
+  void SetVReg(Method* m, int vreg, uint32_t new_value)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   uintptr_t GetGPR(uint32_t reg) const;
 
@@ -368,13 +370,13 @@
   }
 
  private:
-  size_t ComputeNumFrames() const;
+  size_t ComputeNumFrames() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   TraceStackFrame GetTraceStackFrame(uint32_t depth) const {
     return trace_stack_->at(trace_stack_->size() - depth - 1);
   }
 
-  void SanityCheckFrame();
+  void SanityCheckFrame() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   const ManagedStack* const stack_start_;
   const std::vector<TraceStackFrame>* const trace_stack_;
diff --git a/src/thread.cc b/src/thread.cc
index e5ade4d..3bae0af 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -40,7 +40,7 @@
 #include "reflection.h"
 #include "runtime.h"
 #include "runtime_support.h"
-#include "scoped_jni_thread_state.h"
+#include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
 #include "space.h"
 #include "stack.h"
@@ -53,6 +53,7 @@
 namespace art {
 
 pthread_key_t Thread::pthread_key_self_;
+ConditionVariable* Thread::resume_cond_;
 
 static const char* kThreadNameDuringStartup = "<native thread without managed peer>";
 
@@ -101,15 +102,10 @@
   Thread* self = reinterpret_cast<Thread*>(arg);
   self->Init();
 
-  // Wait until it's safe to start running code. (There may have been a suspend-all
-  // in progress while we were starting up.)
-  Runtime* runtime = Runtime::Current();
-  runtime->GetThreadList()->WaitForGo();
-
   {
-    ScopedJniThreadState ts(self);
+    ScopedObjectAccess soa(self);
     {
-      SirtRef<String> thread_name(self->GetThreadName(ts));
+      SirtRef<String> thread_name(self->GetThreadName(soa));
       self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
     }
 
@@ -119,29 +115,37 @@
     CHECK(self->peer_ != NULL);
     Object* receiver = self->peer_;
     jmethodID mid = WellKnownClasses::java_lang_Thread_run;
-    Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(ts.DecodeMethod(mid));
+    Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
     m->Invoke(self, receiver, NULL, NULL);
   }
 
-  // Detach.
-  runtime->GetThreadList()->Unregister();
+  // Detach and delete self.
+  Runtime::Current()->GetThreadList()->Unregister(self);
 
   return NULL;
 }
 
-static void SetVmData(const ScopedJniThreadState& ts, Object* managed_thread,
-                      Thread* native_thread) {
-  Field* f = ts.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
+static void SetVmData(const ScopedObjectAccess& soa, Object* managed_thread,
+                      Thread* native_thread)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+  Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
   f->SetInt(managed_thread, reinterpret_cast<uintptr_t>(native_thread));
 }
 
-Thread* Thread::FromManagedThread(const ScopedJniThreadState& ts, Object* thread_peer) {
-  Field* f = ts.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
-  return reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
+Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, Object* thread_peer) {
+  Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
+  Thread* result = reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
+  // Sanity check that if we have a result it is either suspended or we hold the thread_list_lock_
+  // to stop it from going away.
+  MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+  if (result != NULL && !result->IsSuspended()) {
+    GlobalSynchronization::thread_list_lock_->AssertHeld();
+  }
+  return result;
 }
 
-Thread* Thread::FromManagedThread(const ScopedJniThreadState& ts, jobject java_thread) {
-  return FromManagedThread(ts, ts.Decode<Object*>(java_thread));
+Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, jobject java_thread) {
+  return FromManagedThread(soa, soa.Decode<Object*>(java_thread));
 }
 
 static size_t FixStackSize(size_t stack_size) {
@@ -210,42 +214,38 @@
 void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool daemon) {
   Thread* native_thread = new Thread(daemon);
   {
-    ScopedJniThreadState ts(env);
-    Object* peer = ts.Decode<Object*>(java_peer);
+    ScopedObjectAccess soa(env);
+    Object* peer = soa.Decode<Object*>(java_peer);
     CHECK(peer != NULL);
     native_thread->peer_ = peer;
 
     stack_size = FixStackSize(stack_size);
 
-    // Thread.start is synchronized, so we know that vmData is 0,
-    // and know that we're not racing to assign it.
-    SetVmData(ts, peer, native_thread);
-
-    int pthread_create_result = 0;
-    {
-      ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
-      pthread_t new_pthread;
-      pthread_attr_t attr;
-      CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
-      CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
-      CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
-      pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, native_thread);
-      CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
-    }
-
-    if (pthread_create_result != 0) {
-      // pthread_create(3) failed, so clean up.
-      SetVmData(ts, peer, 0);
-      delete native_thread;
-
-      std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
-                                   PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
-      Thread::Current()->ThrowOutOfMemoryError(msg.c_str());
-      return;
-    }
+    // Thread.start is synchronized, so we know that vmData is 0, and know that we're not racing to
+    // assign it.
+    SetVmData(soa, peer, native_thread);
   }
-  // Let the child know when it's safe to start running.
-  Runtime::Current()->GetThreadList()->SignalGo(native_thread);
+
+  pthread_t new_pthread;
+  pthread_attr_t attr;
+  CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
+  CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
+  CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
+  int pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, native_thread);
+  CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
+
+  if (UNLIKELY(pthread_create_result != 0)) {
+    // pthread_create(3) failed, so clean up.
+    ScopedObjectAccess soa(env);
+    Object* peer = soa.Decode<Object*>(java_peer);
+    SetVmData(soa, peer, 0);
+    delete native_thread;
+
+    std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
+                                 PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
+    Thread::Current()->ThrowOutOfMemoryError(msg.c_str());
+    return;
+  }
 }
 
 void Thread::Init() {
@@ -262,7 +262,9 @@
 
   Runtime* runtime = Runtime::Current();
   CHECK(runtime != NULL);
-
+  if (runtime->IsShuttingDown()) {
+    UNIMPLEMENTED(WARNING) << "Thread attaching whilst runtime is shutting down";
+  }
   thin_lock_id_ = runtime->GetThreadList()->AllocThreadId();
   pthread_self_ = pthread_self();
 
@@ -273,14 +275,18 @@
 
   jni_env_ = new JNIEnvExt(this, runtime->GetJavaVM());
 
-  runtime->GetThreadList()->Register();
+  runtime->GetThreadList()->Register(this);
 }
 
 Thread* Thread::Attach(const char* thread_name, bool as_daemon, jobject thread_group) {
   Thread* self = new Thread(as_daemon);
   self->Init();
 
-  self->SetState(kNative);
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_NE(self->GetState(), kRunnable);
+    self->SetState(kNative);
+  }
 
   // If we're the main thread, ClassLinker won't be created until after we're attached,
   // so that thread needs a two-stage attach. Regular threads don't need this hack.
@@ -313,30 +319,33 @@
   jboolean thread_is_daemon = as_daemon;
 
   ScopedLocalRef<jobject> peer(env, env->AllocObject(WellKnownClasses::java_lang_Thread));
-  peer_ = DecodeJObject(peer.get());
-  if (peer_ == NULL) {
-    CHECK(IsExceptionPending());
-    return;
+  {
+    ScopedObjectAccess soa(env);
+    peer_ = DecodeJObject(peer.get());
+    if (peer_ == NULL) {
+      CHECK(IsExceptionPending());
+      return;
+    }
   }
   env->CallNonvirtualVoidMethod(peer.get(),
                                 WellKnownClasses::java_lang_Thread,
                                 WellKnownClasses::java_lang_Thread_init,
                                 thread_group, thread_name.get(), thread_priority, thread_is_daemon);
-  CHECK(!IsExceptionPending()) << " " << PrettyTypeOf(GetException());
+  AssertNoPendingException();
 
-  ScopedJniThreadState ts(this);
-  SetVmData(ts, peer_, Thread::Current());
-  SirtRef<String> peer_thread_name(GetThreadName(ts));
+  ScopedObjectAccess soa(this);
+  SetVmData(soa, peer_, Thread::Current());
+  SirtRef<String> peer_thread_name(GetThreadName(soa));
   if (peer_thread_name.get() == NULL) {
     // The Thread constructor should have set the Thread.name to a
     // non-null value. However, because we can run without code
     // available (in the compiler, in tests), we manually assign the
     // fields the constructor should have set.
-    ts.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->SetBoolean(peer_, thread_is_daemon);
-    ts.DecodeField(WellKnownClasses::java_lang_Thread_group)->SetObject(peer_, ts.Decode<Object*>(thread_group));
-    ts.DecodeField(WellKnownClasses::java_lang_Thread_name)->SetObject(peer_, ts.Decode<Object*>(thread_name.get()));
-    ts.DecodeField(WellKnownClasses::java_lang_Thread_priority)->SetInt(peer_, thread_priority);
-    peer_thread_name.reset(GetThreadName(ts));
+    soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->SetBoolean(peer_, thread_is_daemon);
+    soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->SetObject(peer_, soa.Decode<Object*>(thread_group));
+    soa.DecodeField(WellKnownClasses::java_lang_Thread_name)->SetObject(peer_, soa.Decode<Object*>(thread_name.get()));
+    soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->SetInt(peer_, thread_priority);
+    peer_thread_name.reset(GetThreadName(soa));
   }
   // 'thread_name' may have been null, so don't trust 'peer_thread_name' to be non-null.
   if (peer_thread_name.get() != NULL) {
@@ -403,27 +412,27 @@
   CHECK_GT(&stack_variable, reinterpret_cast<void*>(stack_end_));
 }
 
-void Thread::Dump(std::ostream& os, bool full) const {
-  if (full) {
-    DumpState(os);
-    DumpStack(os);
-  } else {
-    os << "Thread[";
-    if (GetThinLockId() != 0) {
-      // If we're in kStarting, we won't have a thin lock id or tid yet.
-      os << GetThinLockId()
-         << ",tid=" << GetTid() << ',';
-    }
-    os << GetState()
-       << ",Thread*=" << this
-       << ",peer=" << peer_
-       << ",\"" << *name_ << "\""
-       << "]";
+void Thread::ShortDump(std::ostream& os) const {
+  os << "Thread[";
+  if (GetThinLockId() != 0) {
+    // If we're in kStarting, we won't have a thin lock id or tid yet.
+    os << GetThinLockId()
+             << ",tid=" << GetTid() << ',';
   }
+  os << GetStateUnsafe()
+           << ",Thread*=" << this
+           << ",peer=" << peer_
+           << ",\"" << *name_ << "\""
+           << "]";
 }
 
-String* Thread::GetThreadName(const ScopedJniThreadState& ts) const {
-  Field* f = ts.DecodeField(WellKnownClasses::java_lang_Thread_name);
+void Thread::Dump(std::ostream& os) const {
+  DumpState(os);
+  DumpStack(os);
+}
+
+String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
+  Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
   return (peer_ != NULL) ? reinterpret_cast<String*>(f->GetObject(peer_)) : NULL;
 }
 
@@ -431,19 +440,177 @@
   name.assign(*name_);
 }
 
+// Attempt to rectify locks so that we dump thread list with required locks before exiting.
+static void UnsafeLogFatalForSuspendCount(Thread* self) NO_THREAD_SAFETY_ANALYSIS {
+  GlobalSynchronization::thread_suspend_count_lock_->Unlock();
+  GlobalSynchronization::mutator_lock_->SharedTryLock();
+  if (!GlobalSynchronization::mutator_lock_->IsSharedHeld()) {
+    LOG(WARNING) << "Dumping thread list without holding mutator_lock_";
+  }
+  GlobalSynchronization::thread_list_lock_->TryLock();
+  if (!GlobalSynchronization::thread_list_lock_->IsExclusiveHeld()) {
+    LOG(WARNING) << "Dumping thread list without holding thread_list_lock_";
+  }
+  std::ostringstream ss;
+  Runtime::Current()->GetThreadList()->DumpLocked(ss);
+  LOG(FATAL) << self << " suspend count already zero.\n" << ss.str();
+}
+
+void Thread::ModifySuspendCount(int delta, bool for_debugger) {
+  DCHECK(delta == -1 || delta == +1 || delta == -debug_suspend_count_)
+      << delta << " " << debug_suspend_count_ << " " << this;
+  DCHECK_GE(suspend_count_, debug_suspend_count_) << this;
+  GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
+
+  if (delta == -1 && suspend_count_ <= 0) {
+    // This is expected if you attach a thread during a GC.
+    if (UNLIKELY(!IsStillStarting())) {
+      UnsafeLogFatalForSuspendCount(this);
+    }
+    return;
+  }
+  suspend_count_ += delta;
+  if (for_debugger) {
+    debug_suspend_count_ += delta;
+  }
+}
+
+void Thread::FullSuspendCheck() {
+  VLOG(threads) << this << " self-suspending";
+  // Make thread appear suspended to other threads, release mutator_lock_.
+  TransitionFromRunnableToSuspended(kSuspended);
+  // Transition back to runnable noting requests to suspend, re-acquire share on mutator_lock_.
+  TransitionFromSuspendedToRunnable();
+  VLOG(threads) << this << " self-reviving";
+}
+
+void Thread::TransitionFromRunnableToSuspended(ThreadState new_state) {
+  AssertThreadSuspensionIsAllowable();
+  CHECK_NE(new_state, kRunnable);
+  CHECK_EQ(this, Thread::Current());
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_EQ(GetState(), kRunnable);
+    SetState(new_state);
+  }
+  // Release share on mutator_lock_.
+  GlobalSynchronization::mutator_lock_->SharedUnlock();
+}
+
+ThreadState Thread::TransitionFromSuspendedToRunnable() {
+  bool done = false;
+  ThreadState old_state;
+  do {
+    {
+      // Wait while our suspend count is non-zero.
+      MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+      old_state = GetState();
+      CHECK_NE(old_state, kRunnable);
+      GlobalSynchronization::mutator_lock_->AssertNotHeld();  // Otherwise we starve GC..
+      while (GetSuspendCount() != 0) {
+        // Re-check when Thread::resume_cond_ is notified.
+        Thread::resume_cond_->Wait(*GlobalSynchronization::thread_suspend_count_lock_);
+      }
+    }
+    // Re-acquire shared mutator_lock_ access.
+    GlobalSynchronization::mutator_lock_->SharedLock();
+    // Holding the mutator_lock_, synchronize with any thread trying to raise the suspend count
+    // and change state to Runnable if no suspend is pending.
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    if (GetSuspendCount() == 0) {
+      SetState(kRunnable);
+      done = true;
+    } else {
+      // Release shared mutator_lock_ access and try again.
+      GlobalSynchronization::mutator_lock_->SharedUnlock();
+    }
+  } while (!done);
+  return old_state;
+}
+
+Thread* Thread::SuspendForDebugger(jobject peer, bool request_suspension, bool* timeout) {
+  static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
+  useconds_t total_delay_us = 0;
+  useconds_t delay_us = 0;
+  bool did_suspend_request = false;
+  *timeout = false;
+  while (true) {
+    Thread* thread;
+    {
+      ScopedObjectAccess soa(Thread::Current());
+      MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+      thread = Thread::FromManagedThread(soa, peer);
+      if (thread == NULL) {
+        LOG(WARNING) << "No such thread for suspend: " << peer;
+        return NULL;
+      }
+      {
+        MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+        if (request_suspension) {
+          thread->ModifySuspendCount(+1, true /* for_debugger */);
+          request_suspension = false;
+          did_suspend_request = true;
+        }
+        // IsSuspended on the current thread will fail as the current thread is changed into
+        // Runnable above. As the suspend count is now raised if this is the current thread
+        // it will self suspend on transition to Runnable, making it hard to work with. Its simpler
+        // to just explicitly handle the current thread in the callers to this code.
+        CHECK_NE(thread, soa.Self()) << "Attempt to suspend for debugger the current thread";
+        // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
+        // count, or else we've waited and it has self suspended) or is the current thread, we're
+        // done.
+        if (thread->IsSuspended()) {
+          return thread;
+        }
+        if (total_delay_us >= kTimeoutUs) {
+          LOG(ERROR) << "Thread suspension timed out: " << peer;
+          if (did_suspend_request) {
+            thread->ModifySuspendCount(-1, true /* for_debugger */);
+          }
+          *timeout = true;
+          return NULL;
+        }
+      }
+      // Release locks and come out of runnable state.
+    }
+    for (int i = kMaxMutexLevel; i >= 0; --i) {
+      BaseMutex* held_mutex = Thread::Current()->GetHeldMutex(static_cast<MutexLevel>(i));
+      if (held_mutex != NULL) {
+        LOG(FATAL) << "Holding " << held_mutex->GetName()
+            << " while sleeping for thread suspension";
+      }
+    }
+    {
+      useconds_t new_delay_us = delay_us * 2;
+      CHECK_GE(new_delay_us, delay_us);
+      if (new_delay_us < 500000) {  // Don't allow sleeping to be more than 0.5s.
+        delay_us = new_delay_us;
+      }
+    }
+    if (delay_us == 0) {
+      sched_yield();
+      // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep).
+      delay_us = 500;
+    } else {
+      usleep(delay_us);
+      total_delay_us += delay_us;
+    }
+  }
+}
+
 void Thread::DumpState(std::ostream& os, const Thread* thread, pid_t tid) {
   std::string group_name;
   int priority;
   bool is_daemon = false;
 
   if (thread != NULL && thread->peer_ != NULL) {
-    ScopedJniThreadState ts(Thread::Current());
-    priority = ts.DecodeField(WellKnownClasses::java_lang_Thread_priority)->GetInt(thread->peer_);
-    is_daemon = ts.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(thread->peer_);
+    ScopedObjectAccess soa(Thread::Current());
+    priority = soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->GetInt(thread->peer_);
+    is_daemon = soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(thread->peer_);
 
-    Object* thread_group = thread->GetThreadGroup(ts);
+    Object* thread_group = thread->GetThreadGroup(soa);
     if (thread_group != NULL) {
-      Field* group_name_field = ts.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
+      Field* group_name_field = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
       String* group_name_string = reinterpret_cast<String*>(group_name_field->GetObject(thread_group));
       group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
     }
@@ -461,6 +628,7 @@
     if (is_daemon) {
       os << " daemon";
     }
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
     os << " prio=" << priority
        << " tid=" << thread->GetThinLockId()
        << " " << thread->GetState() << "\n";
@@ -471,6 +639,7 @@
   }
 
   if (thread != NULL) {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
     os << "  | group=\"" << group_name << "\""
        << " sCount=" << thread->suspend_count_
        << " dsCount=" << thread->debug_suspend_count_
@@ -520,6 +689,7 @@
 
 struct StackDumpVisitor : public StackVisitor {
   StackDumpVisitor(std::ostream& os, const Thread* thread, Context* context, bool can_allocate)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(thread->GetManagedStack(), thread->GetTraceStack(), context),
         os(os), thread(thread), can_allocate(can_allocate),
         last_method(NULL), last_line_number(0), repetition_count(0), frame_count(0) {
@@ -531,7 +701,7 @@
     }
   }
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* m = GetMethod();
     if (m->IsRuntimeMethod()) {
       return true;
@@ -589,7 +759,12 @@
 
 void Thread::DumpStack(std::ostream& os) const {
   // If we're currently in native code, dump that stack before dumping the managed stack.
-  if (GetState() == kNative || GetState() == kVmWait) {
+  ThreadState state;
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    state = GetState();
+  }
+  if (state == kNative) {
     DumpKernelStack(os, GetTid(), "  kernel: ", false);
     DumpNativeStack(os, GetTid(), "  native: ", false);
   }
@@ -598,148 +773,6 @@
   dumper.WalkStack();
 }
 
-void Thread::SetStateWithoutSuspendCheck(ThreadState new_state) {
-  DCHECK_EQ(this, Thread::Current());
-  volatile void* raw = reinterpret_cast<volatile void*>(&state_);
-  volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
-  android_atomic_release_store(new_state, addr);
-}
-
-ThreadState Thread::SetState(ThreadState new_state) {
-  if (new_state != kVmWait && new_state != kTerminated) {
-    // TODO: kVmWait is set by the parent thread to a child thread to indicate it can go. Similarly
-    // kTerminated may be set by a parent thread to its child if pthread creation fails.  This
-    // overloaded use of the state variable means we cannot fully assert that only threads
-    // themselves modify their state.
-    DCHECK_EQ(this, Thread::Current());
-  }
-  ThreadState old_state = state_;
-  if (old_state == kRunnable) {
-    // Non-runnable states are points where we expect thread suspension can occur.
-    AssertThreadSuspensionIsAllowable();
-  }
-
-  if (old_state == new_state) {
-    return old_state;
-  }
-
-  volatile void* raw = reinterpret_cast<volatile void*>(&state_);
-  volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
-
-  if (new_state == kRunnable) {
-    /*
-     * Change our status to kRunnable.  The transition requires
-     * that we check for pending suspension, because the runtime considers
-     * us to be "asleep" in all other states, and another thread could
-     * be performing a GC now.
-     *
-     * The order of operations is very significant here.  One way to
-     * do this wrong is:
-     *
-     *   GCing thread                   Our thread (in kNative)
-     *   ------------                   ----------------------
-     *                                  check suspend count (== 0)
-     *   SuspendAllThreads()
-     *   grab suspend-count lock
-     *   increment all suspend counts
-     *   release suspend-count lock
-     *   check thread state (== kNative)
-     *   all are suspended, begin GC
-     *                                  set state to kRunnable
-     *                                  (continue executing)
-     *
-     * We can correct this by grabbing the suspend-count lock and
-     * performing both of our operations (check suspend count, set
-     * state) while holding it, now we need to grab a mutex on every
-     * transition to kRunnable.
-     *
-     * What we do instead is change the order of operations so that
-     * the transition to kRunnable happens first.  If we then detect
-     * that the suspend count is nonzero, we switch to kSuspended.
-     *
-     * Appropriate compiler and memory barriers are required to ensure
-     * that the operations are observed in the expected order.
-     *
-     * This does create a small window of opportunity where a GC in
-     * progress could observe what appears to be a running thread (if
-     * it happens to look between when we set to kRunnable and when we
-     * switch to kSuspended).  At worst this only affects assertions
-     * and thread logging.  (We could work around it with some sort
-     * of intermediate "pre-running" state that is generally treated
-     * as equivalent to running, but that doesn't seem worthwhile.)
-     *
-     * We can also solve this by combining the "status" and "suspend
-     * count" fields into a single 32-bit value.  This trades the
-     * store/load barrier on transition to kRunnable for an atomic RMW
-     * op on all transitions and all suspend count updates (also, all
-     * accesses to status or the thread count require bit-fiddling).
-     * It also eliminates the brief transition through kRunnable when
-     * the thread is supposed to be suspended.  This is possibly faster
-     * on SMP and slightly more correct, but less convenient.
-     */
-    AssertThreadSuspensionIsAllowable();
-    android_atomic_acquire_store(new_state, addr);
-    ANNOTATE_IGNORE_READS_BEGIN();
-    int suspend_count = suspend_count_;
-    ANNOTATE_IGNORE_READS_END();
-    if (suspend_count != 0) {
-      Runtime::Current()->GetThreadList()->FullSuspendCheck(this);
-    }
-  } else {
-    /*
-     * Not changing to kRunnable. No additional work required.
-     *
-     * We use a releasing store to ensure that, if we were runnable,
-     * any updates we previously made to objects on the managed heap
-     * will be observed before the state change.
-     */
-    android_atomic_release_store(new_state, addr);
-  }
-
-  return old_state;
-}
-
-bool Thread::IsSuspended() {
-  ANNOTATE_IGNORE_READS_BEGIN();
-  int suspend_count = suspend_count_;
-  ANNOTATE_IGNORE_READS_END();
-  return suspend_count != 0 && GetState() != kRunnable;
-}
-
-static void ReportThreadSuspendTimeout(Thread* waiting_thread) {
-  Runtime* runtime = Runtime::Current();
-  std::ostringstream ss;
-  ss << "Thread suspend timeout waiting for thread " << *waiting_thread << "\n";
-  runtime->DumpLockHolders(ss);
-  ss << "\n";
-  runtime->GetThreadList()->DumpLocked(ss);
-  LOG(FATAL) << ss.str();
-}
-
-void Thread::WaitUntilSuspended() {
-  static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
-
-  useconds_t total_delay = 0;
-  useconds_t delay = 0;
-  while (GetState() == kRunnable) {
-    if (total_delay >= kTimeoutUs) {
-      ReportThreadSuspendTimeout(this);
-    }
-    useconds_t new_delay = delay * 2;
-    CHECK_GE(new_delay, delay);
-    delay = new_delay;
-    if (delay == 0) {
-      sched_yield();
-      // Default to 1 milliseconds (note that this gets multiplied by 2 before
-      // the first sleep)
-      delay = 500;
-    } else {
-      usleep(delay);
-      total_delay += delay;
-    }
-  }
-}
-
 void Thread::ThreadExitCallback(void* arg) {
   Thread* self = reinterpret_cast<Thread*>(arg);
   if (self->thread_exit_check_count_ == 0) {
@@ -752,6 +785,11 @@
 }
 
 void Thread::Startup() {
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);  // Keep GCC happy.
+    resume_cond_ = new ConditionVariable("Thread resumption condition variable");
+  }
+
   // Allocate a TLS slot.
   CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
 
@@ -764,13 +802,11 @@
 void Thread::FinishStartup() {
   Runtime* runtime = Runtime::Current();
   CHECK(runtime->IsStarted());
-  Thread* self = Thread::Current();
 
   // Finish attaching the main thread.
-  ScopedThreadStateChange tsc(self, kRunnable);
+  ScopedObjectAccess soa(Thread::Current());
   Thread::Current()->CreatePeer("main", false, runtime->GetMainThreadGroup());
 
-  InitBoxingMethods();
   Runtime::Current()->GetClassLinker()->RunRootClinits();
 }
 
@@ -808,6 +844,7 @@
       trace_stack_(new std::vector<TraceStackFrame>),
       name_(new std::string(kThreadNameDuringStartup)),
       daemon_(daemon),
+      pthread_self_(0),
       no_thread_suspension_(0),
       last_no_thread_suspension_cause_(NULL),
       thread_exit_check_count_(0) {
@@ -825,36 +862,49 @@
   return (*name_ == kThreadNameDuringStartup);
 }
 
-static void MonitorExitVisitor(const Object* object, void*) {
+void Thread::AssertNoPendingException() const {
+  if (UNLIKELY(IsExceptionPending())) {
+    ScopedObjectAccess soa(Thread::Current());
+    Throwable* exception = GetException();
+    LOG(FATAL) << "No pending exception expected: " << exception->Dump();
+  }
+}
+
+static void MonitorExitVisitor(const Object* object, void* arg) NO_THREAD_SAFETY_ANALYSIS {
+  Thread* self = reinterpret_cast<Thread*>(arg);
   Object* entered_monitor = const_cast<Object*>(object);
-  LOG(WARNING) << "Calling MonitorExit on object " << object << " (" << PrettyTypeOf(object) << ")"
-               << " left locked by native thread " << *Thread::Current() << " which is detaching";
-  entered_monitor->MonitorExit(Thread::Current());
+  if (self->HoldsLock(entered_monitor)) {
+    LOG(WARNING) << "Calling MonitorExit on object "
+                 << object << " (" << PrettyTypeOf(object) << ")"
+                 << " left locked by native thread "
+                 << *Thread::Current() << " which is detaching";
+    entered_monitor->MonitorExit(self);
+  }
 }
 
 void Thread::Destroy() {
   // On thread detach, all monitors entered with JNI MonitorEnter are automatically exited.
   if (jni_env_ != NULL) {
-    jni_env_->monitors.VisitRoots(MonitorExitVisitor, NULL);
+    jni_env_->monitors.VisitRoots(MonitorExitVisitor, Thread::Current());
   }
 
   if (peer_ != NULL) {
     Thread* self = this;
 
     // We may need to call user-supplied managed code.
-    ScopedJniThreadState ts(this);
+    ScopedObjectAccess soa(this);
 
-    HandleUncaughtExceptions(ts);
-    RemoveFromThreadGroup(ts);
+    HandleUncaughtExceptions(soa);
+    RemoveFromThreadGroup(soa);
 
     // this.vmData = 0;
-    SetVmData(ts, peer_, NULL);
+    SetVmData(soa, peer_, NULL);
 
     Dbg::PostThreadDeath(self);
 
     // Thread.join() is implemented as an Object.wait() on the Thread.lock
     // object. Signal anyone who is waiting.
-    Object* lock = ts.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(peer_);
+    Object* lock = soa.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(peer_);
     // (This conditional is only needed for tests, where Thread.lock won't have been set.)
     if (lock != NULL) {
       lock->MonitorEnter(self);
@@ -868,7 +918,11 @@
   delete jni_env_;
   jni_env_ = NULL;
 
-  SetState(kTerminated);
+  {
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_NE(GetState(), kRunnable);
+    SetState(kTerminated);
+  }
 
   delete wait_cond_;
   delete wait_mutex_;
@@ -884,7 +938,7 @@
   TearDownAlternateSignalStack();
 }
 
-void Thread::HandleUncaughtExceptions(const ScopedJniThreadState& ts) {
+void Thread::HandleUncaughtExceptions(const ScopedObjectAccess& soa) {
   if (!IsExceptionPending()) {
     return;
   }
@@ -894,15 +948,15 @@
 
   // If the thread has its own handler, use that.
   Object* handler =
-      ts.DecodeField(WellKnownClasses::java_lang_Thread_uncaughtHandler)->GetObject(peer_);
+      soa.DecodeField(WellKnownClasses::java_lang_Thread_uncaughtHandler)->GetObject(peer_);
   if (handler == NULL) {
     // Otherwise use the thread group's default handler.
-    handler = GetThreadGroup(ts);
+    handler = GetThreadGroup(soa);
   }
 
   // Call the handler.
   jmethodID mid = WellKnownClasses::java_lang_Thread$UncaughtExceptionHandler_uncaughtException;
-  Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(ts.DecodeMethod(mid));
+  Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
   JValue args[2];
   args[0].SetL(peer_);
   args[1].SetL(exception);
@@ -912,17 +966,17 @@
   ClearException();
 }
 
-Object* Thread::GetThreadGroup(const ScopedJniThreadState& ts) const {
-  return ts.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer_);
+Object* Thread::GetThreadGroup(const ScopedObjectAccessUnchecked& soa) const {
+  return soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer_);
 }
 
-void Thread::RemoveFromThreadGroup(const ScopedJniThreadState& ts) {
+void Thread::RemoveFromThreadGroup(const ScopedObjectAccess& soa) {
   // this.group.removeThread(this);
   // group can be null if we're in the compiler or a test.
-  Object* group = GetThreadGroup(ts);
+  Object* group = GetThreadGroup(soa);
   if (group != NULL) {
     jmethodID mid = WellKnownClasses::java_lang_ThreadGroup_removeThread;
-    Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(ts.DecodeMethod(mid));
+    Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
     JValue args[1];
     args[0].SetL(peer_);
     m->Invoke(this, group, args, NULL);
@@ -1023,10 +1077,11 @@
  public:
   CountStackDepthVisitor(const ManagedStack* stack,
                          const std::vector<TraceStackFrame>* trace_stack)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(stack, trace_stack, NULL),
         depth_(0), skip_depth_(0), skipping_(true) {}
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // We want to skip frames up to and including the exception's constructor.
     // Note we also skip the frame if it doesn't have a method (namely the callee
     // save frame)
@@ -1067,7 +1122,8 @@
       : StackVisitor(stack, trace_stack, NULL),
         skip_depth_(skip_depth), count_(0), dex_pc_trace_(NULL), method_trace_(NULL) {}
 
-  bool Init(int depth, const ScopedJniThreadState& ts) {
+  bool Init(int depth, const ScopedObjectAccess& soa)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     // Allocate method trace with an extra slot that will hold the PC trace
     SirtRef<ObjectArray<Object> >
       method_trace(Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1));
@@ -1083,7 +1139,7 @@
     method_trace->Set(depth, dex_pc_trace);
     // Set the Object*s and assert that no thread suspension is now possible.
     const char* last_no_suspend_cause =
-        ts.Self()->StartAssertNoThreadSuspension("Building internal stack trace");
+        soa.Self()->StartAssertNoThreadSuspension("Building internal stack trace");
     CHECK(last_no_suspend_cause == NULL) << last_no_suspend_cause;
     method_trace_ = method_trace.get();
     dex_pc_trace_ = dex_pc_trace;
@@ -1096,7 +1152,7 @@
     }
   }
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (method_trace_ == NULL || dex_pc_trace_ == NULL) {
       return true; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
     }
@@ -1141,7 +1197,7 @@
   return sirt;
 }
 
-jobject Thread::CreateInternalStackTrace(const ScopedJniThreadState& ts) const {
+jobject Thread::CreateInternalStackTrace(const ScopedObjectAccess& soa) const {
   // Compute depth of stack
   CountStackDepthVisitor count_visitor(GetManagedStack(), GetTraceStack());
   count_visitor.WalkStack();
@@ -1151,19 +1207,19 @@
   // Build internal stack trace
   BuildInternalStackTraceVisitor build_trace_visitor(GetManagedStack(), GetTraceStack(),
                                                      skip_depth);
-  if (!build_trace_visitor.Init(depth, ts)) {
+  if (!build_trace_visitor.Init(depth, soa)) {
     return NULL;  // Allocation failed
   }
   build_trace_visitor.WalkStack();
-  return ts.AddLocalReference<jobjectArray>(build_trace_visitor.GetInternalStackTrace());
+  return soa.AddLocalReference<jobjectArray>(build_trace_visitor.GetInternalStackTrace());
 }
 
 jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
     jobjectArray output_array, int* stack_depth) {
   // Transition into runnable state to work on Object*/Array*
-  ScopedJniThreadState ts(env);
+  ScopedObjectAccess soa(env);
   // Decode the internal stack trace into the depth, method trace and PC trace
-  ObjectArray<Object>* method_trace = ts.Decode<ObjectArray<Object>*>(internal);
+  ObjectArray<Object>* method_trace = soa.Decode<ObjectArray<Object>*>(internal);
   int32_t depth = method_trace->GetLength() - 1;
   IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
 
@@ -1174,7 +1230,7 @@
   if (output_array != NULL) {
     // Reuse the array we were given.
     result = output_array;
-    java_traces = ts.Decode<ObjectArray<StackTraceElement>*>(output_array);
+    java_traces = soa.Decode<ObjectArray<StackTraceElement>*>(output_array);
     // ...adjusting the number of frames we'll write to not exceed the array length.
     depth = std::min(depth, java_traces->GetLength());
   } else {
@@ -1183,7 +1239,7 @@
     if (java_traces == NULL) {
       return NULL;
     }
-    result = ts.AddLocalReference<jobjectArray>(java_traces);
+    result = soa.AddLocalReference<jobjectArray>(java_traces);
   }
 
   if (stack_depth != NULL) {
@@ -1223,8 +1279,8 @@
     }
 #ifdef MOVING_GARBAGE_COLLECTOR
     // Re-read after potential GC
-    java_traces = Decode<ObjectArray<Object>*>(ts.Env(), result);
-    method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(ts.Env(), internal));
+    java_traces = Decode<ObjectArray<Object>*>(soa.Env(), result);
+    method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(soa.Env(), internal));
     pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
 #endif
     java_traces->Set(i, obj);
@@ -1246,7 +1302,7 @@
 }
 
 void Thread::ThrowNewException(const char* exception_class_descriptor, const char* msg) {
-  CHECK(!IsExceptionPending()); // Callers should either clear or call ThrowNewWrappedException.
+  AssertNoPendingException(); // Callers should either clear or call ThrowNewWrappedException.
   ThrowNewWrappedException(exception_class_descriptor, msg);
 }
 
@@ -1276,10 +1332,10 @@
     ScopedLocalRef<jthrowable> exception(
         env, reinterpret_cast<jthrowable>(env->AllocObject(exception_class.get())));
     if (exception.get() != NULL) {
-      ScopedJniThreadState ts(env);
-      Throwable* t = reinterpret_cast<Throwable*>(ts.Self()->DecodeJObject(exception.get()));
+      ScopedObjectAccessUnchecked soa(env);
+      Throwable* t = reinterpret_cast<Throwable*>(soa.Self()->DecodeJObject(exception.get()));
       t->SetDetailMessage(String::AllocFromModifiedUtf8(msg));
-      ts.Self()->SetException(t);
+      soa.Self()->SetException(t);
     } else {
       LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI AllocObject failed: "
                  << PrettyTypeOf(GetException());
@@ -1358,8 +1414,13 @@
   ENTRY_POINT_INFO(pGetObjInstance),
   ENTRY_POINT_INFO(pGetObjStatic),
   ENTRY_POINT_INFO(pHandleFillArrayDataFromCode),
-  ENTRY_POINT_INFO(pDecodeJObjectInThread),
   ENTRY_POINT_INFO(pFindNativeMethod),
+  ENTRY_POINT_INFO(pJniMethodStart),
+  ENTRY_POINT_INFO(pJniMethodStartSynchronized),
+  ENTRY_POINT_INFO(pJniMethodEnd),
+  ENTRY_POINT_INFO(pJniMethodEndSynchronized),
+  ENTRY_POINT_INFO(pJniMethodEndWithReference),
+  ENTRY_POINT_INFO(pJniMethodEndWithReferenceSynchronized),
   ENTRY_POINT_INFO(pLockObjectFromCode),
   ENTRY_POINT_INFO(pUnlockObjectFromCode),
   ENTRY_POINT_INFO(pCmpgDouble),
@@ -1452,6 +1513,7 @@
 class CatchBlockStackVisitor : public StackVisitor {
  public:
   CatchBlockStackVisitor(Thread* self, Throwable* exception)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(self->GetManagedStack(), self->GetTraceStack(), self->GetLongJumpContext()),
         self_(self), exception_(exception), to_find_(exception->GetClass()), throw_method_(NULL),
         throw_frame_id_(0), throw_dex_pc_(0), handler_quick_frame_(NULL),
@@ -1465,7 +1527,8 @@
     LOG(FATAL) << "UNREACHABLE";  // Expected to take long jump.
   }
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* method = GetMethod();
     if (method == NULL) {
       // This is the upcall, we remember the frame and last pc so that we may long jump to them.
@@ -1507,7 +1570,7 @@
     return true;  // Continue stack walk.
   }
 
-  void DoLongJump() {
+  void DoLongJump() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* catch_method = *handler_quick_frame_;
     Dbg::PostException(self_, throw_frame_id_, throw_method_, throw_dex_pc_,
                        catch_method, handler_dex_pc_, exception_);
@@ -1587,9 +1650,10 @@
   struct CurrentMethodVisitor : public StackVisitor {
     CurrentMethodVisitor(const ManagedStack* stack,
                          const std::vector<TraceStackFrame>* trace_stack)
+        SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
         : StackVisitor(stack, trace_stack, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
 
-    virtual bool VisitFrame() {
+    virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
       Method* m = GetMethod();
       if (m->IsRuntimeMethod()) {
         // Continue if this is a runtime method.
@@ -1627,9 +1691,10 @@
  public:
   ReferenceMapVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
                       Context* context, Heap::RootVisitor* root_visitor, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(stack, trace_stack, context), root_visitor_(root_visitor), arg_(arg) {}
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (false) {
       LOG(INFO) << "Visiting stack roots in " << PrettyMethod(GetMethod())
           << StringPrintf("@ PC:%04x", GetDexPc());
@@ -1739,51 +1804,42 @@
 }
 #endif
 
+// Set the stack end to that to be used during a stack overflow
+void Thread::SetStackEndForStackOverflow() {
+  // During stack overflow we allow use of the full stack
+  if (stack_end_ == stack_begin_) {
+    DumpStack(std::cerr);
+    LOG(FATAL) << "Need to increase kStackOverflowReservedBytes (currently "
+               << kStackOverflowReservedBytes << ")";
+  }
+
+  stack_end_ = stack_begin_;
+}
+
 std::ostream& operator<<(std::ostream& os, const Thread& thread) {
-  thread.Dump(os, false);
+  thread.ShortDump(os);
   return os;
 }
 
-void Thread::CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking) {
-  if (this == NULL) {
-    CHECK(Runtime::Current()->IsShuttingDown());
-    return;
-  }
-  if (is_locking) {
-    if (held_mutexes_[rank] == 0) {
-      bool bad_mutexes_held = false;
-      for (int i = kMaxMutexRank; i > rank; --i) {
-        if (held_mutexes_[i] != 0) {
-          LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while " << (is_locking ? "locking" : "unlocking") << " " << rank;
+#ifndef NDEBUG
+void Thread::AssertThreadSuspensionIsAllowable(bool check_locks) const {
+  CHECK_EQ(0u, no_thread_suspension_) << last_no_thread_suspension_cause_;
+  if (check_locks) {
+    bool bad_mutexes_held = false;
+    for (int i = kMaxMutexLevel; i >= 0; --i) {
+      // We expect no locks except the mutator_lock_.
+      if (i != kMutatorLock) {
+        BaseMutex* held_mutex = GetHeldMutex(static_cast<MutexLevel>(i));
+        if (held_mutex != NULL) {
+          LOG(ERROR) << "holding \"" << held_mutex->GetName()
+                  << "\" at point where thread suspension is expected";
           bad_mutexes_held = true;
         }
       }
-      CHECK(!bad_mutexes_held) << rank;
     }
-    ++held_mutexes_[rank];
-  } else {
-    CHECK_GT(held_mutexes_[rank], 0U) << rank;
-    --held_mutexes_[rank];
+    CHECK(!bad_mutexes_held);
   }
 }
-
-void Thread::CheckSafeToWait(MutexRank rank) {
-  if (this == NULL) {
-    CHECK(Runtime::Current()->IsShuttingDown());
-    return;
-  }
-  bool bad_mutexes_held = false;
-  for (int i = kMaxMutexRank; i >= 0; --i) {
-    if (i != rank && held_mutexes_[i] != 0) {
-      LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while doing condition variable wait on " << rank;
-      bad_mutexes_held = true;
-    }
-  }
-  if (held_mutexes_[rank] == 0) {
-    LOG(ERROR) << "*not* holding " << rank << " while doing condition variable wait on it";
-    bad_mutexes_held = true;
-  }
-  CHECK(!bad_mutexes_held);
-}
+#endif
 
 }  // namespace art
diff --git a/src/thread.h b/src/thread.h
index 155c980..48278d8 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -51,6 +51,8 @@
 class Monitor;
 class Object;
 class Runtime;
+class ScopedObjectAccess;
+class ScopedObjectAccessUnchecked;
 class ShadowFrame;
 class StackIndirectReferenceTable;
 class StackTraceElement;
@@ -72,15 +74,23 @@
 };
 
 enum ThreadState {
-  kTerminated   = 0, // Thread.TERMINATED     JDWP TS_ZOMBIE
-  kRunnable     = 1, // Thread.RUNNABLE       JDWP TS_RUNNING
-  kTimedWaiting = 2, // Thread.TIMED_WAITING  JDWP TS_WAIT    - in Object.wait() with a timeout
-  kBlocked      = 3, // Thread.BLOCKED        JDWP TS_MONITOR - blocked on a monitor
-  kWaiting      = 4, // Thread.WAITING        JDWP TS_WAIT    - in Object.wait()
-  kStarting     = 5, // Thread.NEW                            - native thread started, not yet ready to run managed code
-  kNative       = 6, //                                       - running in a JNI native method
-  kVmWait       = 7, //                                       - waiting on an internal runtime resource
-  kSuspended    = 8, //                                       - suspended by GC or debugger
+  kTerminated                     = 0,   // Thread.TERMINATED     JDWP TS_ZOMBIE
+  kRunnable                       = 1,   // Thread.RUNNABLE       JDWP TS_RUNNING
+  kTimedWaiting                   = 2,   // Thread.TIMED_WAITING  JDWP TS_WAIT    - in Object.wait() with a timeout
+  kBlocked                        = 3,   // Thread.BLOCKED        JDWP TS_MONITOR - blocked on a monitor
+  kWaiting                        = 4,   // Thread.WAITING        JDWP TS_WAIT    - in Object.wait()
+  kWaitingForGcToComplete         = 5,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for GC
+  kWaitingPerformingGc            = 6,   // Thread.WAITING        JDWP TS_WAIT    - performing GC
+  kWaitingForDebuggerSend         = 7,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for events to be sent
+  kWaitingForDebuggerToAttach     = 8,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for debugger to attach
+  kWaitingInMainDebuggerLoop      = 9,   // Thread.WAITING        JDWP TS_WAIT    - blocking/reading/processing debugger events
+  kWaitingForDebuggerSuspension   = 10,  // Thread.WAITING        JDWP TS_WAIT    - waiting for debugger suspend all
+  kWaitingForJniOnLoad            = 11,  // Thread.WAITING        JDWP TS_WAIT    - waiting for execution of dlopen and JNI on load code
+  kWaitingForSignalCatcherOutput  = 12,  // Thread.WAITING        JDWP TS_WAIT    - waiting for signal catcher IO to complete
+  kWaitingInMainSignalCatcherLoop = 13,  // Thread.WAITING        JDWP TS_WAIT    - blocking/reading/processing signals
+  kStarting                       = 14,  // Thread.NEW            JDWP TS_WAIT    - native thread started, not yet ready to run managed code
+  kNative                         = 15,  // Thread.RUNNABLE       JDWP TS_RUNNING - running in a JNI native method
+  kSuspended                      = 16,  // Thread.RUNNABLE       JDWP TS_RUNNING - suspended by GC or debugger
 };
 
 class PACKED Thread {
@@ -110,34 +120,90 @@
     return reinterpret_cast<Thread*>(thread);
   }
 
-  static Thread* FromManagedThread(const ScopedJniThreadState& ts, Object* thread_peer);
-  static Thread* FromManagedThread(const ScopedJniThreadState& ts, jobject thread);
+  static Thread* FromManagedThread(const ScopedObjectAccessUnchecked& ts, Object* thread_peer)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static Thread* FromManagedThread(const ScopedObjectAccessUnchecked& ts, jobject thread)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Translates 172 to pAllocArrayFromCode and so on.
   static void DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_pointers);
 
-  // When full == true, dumps the detailed thread state and the thread stack (used for SIGQUIT).
-  // When full == false, dumps a one-line summary of thread state (used for operator<<).
-  void Dump(std::ostream& os, bool full = true) const;
+  // Dumps a one-line summary of thread state (used for operator<<).
+  void ShortDump(std::ostream& os) const;
+
+  // Dumps the detailed thread state and the thread stack (used for SIGQUIT).
+  void Dump(std::ostream& os) const
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Dumps the SIGQUIT per-thread header. 'thread' can be NULL for a non-attached thread, in which
   // case we use 'tid' to identify the thread, and we'll include as much information as we can.
-  static void DumpState(std::ostream& os, const Thread* thread, pid_t tid);
+  static void DumpState(std::ostream& os, const Thread* thread, pid_t tid)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_);
 
-  ThreadState GetState() const {
+  ThreadState GetState() const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_) {
+    GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
     return state_;
   }
 
-  ThreadState SetState(ThreadState new_state);
-  void SetStateWithoutSuspendCheck(ThreadState new_state);
-
-  bool IsDaemon() const {
-    return daemon_;
+  ThreadState SetState(ThreadState new_state)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_) {
+    GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
+    ThreadState old_state = state_;
+    if (new_state == kRunnable) {
+      // Sanity, should never become runnable with a pending suspension and should always hold
+      // share of mutator_lock_.
+      CHECK_EQ(GetSuspendCount(), 0);
+      GlobalSynchronization::mutator_lock_->AssertSharedHeld();
+    }
+    state_ = new_state;
+    return old_state;
   }
 
-  bool IsSuspended();
+  int GetSuspendCount() const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_) {
+    GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
+    return suspend_count_;
+  }
 
-  void WaitUntilSuspended();
+  int GetDebugSuspendCount() const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_) {
+    GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
+    return debug_suspend_count_;
+  }
+
+  bool IsSuspended() const
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_) {
+    int suspend_count = GetSuspendCount();
+    return suspend_count != 0 && GetState() != kRunnable;
+  }
+
+  void ModifySuspendCount(int delta, bool for_debugger)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_suspend_count_lock_);
+
+  // Called when thread detected that the thread_suspend_count_ was non-zero. Gives up share of
+  // mutator_lock_ and waits until it is resumed and thread_suspend_count_ is zero.
+  void FullSuspendCheck() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+
+  // Transition from non-runnable to runnable state acquiring share on mutator_lock_.
+  ThreadState TransitionFromSuspendedToRunnable()
+      SHARED_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_);
+
+  // Transition from runnable into a state where mutator privileges are denied. Releases share of
+  // mutator lock.
+  void TransitionFromRunnableToSuspended(ThreadState new_state)
+      UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_);
+
+  // Wait for a debugger suspension on the thread associated with the given peer. Returns the
+  // thread on success, else NULL. If the thread should be suspended then request_suspension should
+  // be true on entry. If the suspension times out then *timeout is set to true.
+  static Thread* SuspendForDebugger(jobject peer,  bool request_suspension, bool* timeout)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
 
   // Once called thread suspension will cause an assertion failure.
 #ifndef NDEBUG
@@ -168,9 +234,14 @@
   }
 #endif
 
-  void AssertThreadSuspensionIsAllowable() const {
-    DCHECK_EQ(0u, no_thread_suspension_) << last_no_thread_suspension_cause_;
+
+#ifndef NDEBUG
+  void AssertThreadSuspensionIsAllowable(bool check_locks = true) const;
+#else
+  void AssertThreadSuspensionIsAllowable(bool check_locks = true) const {
+    check_locks = !check_locks;  // Keep GCC happy about unused parameters.
   }
+#endif
 
   bool CanAccessDirectReferences() const {
 #ifdef MOVING_GARBAGE_COLLECTOR
@@ -179,6 +250,10 @@
     return true;
   }
 
+  bool IsDaemon() const {
+    return daemon_;
+  }
+
   bool HoldsLock(Object*);
 
   /*
@@ -206,41 +281,46 @@
   }
 
   // Returns the java.lang.Thread's name, or NULL if this Thread* doesn't have a peer.
-  String* GetThreadName(const ScopedJniThreadState& ts) const;
+  String* GetThreadName(const ScopedObjectAccessUnchecked& ts) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
   // allocation, or locking.
   void GetThreadName(std::string& name) const;
 
   // Sets the thread's name.
-  void SetThreadName(const char* name);
+  void SetThreadName(const char* name) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Object* GetPeer() const {
+  Object* GetPeer() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return peer_;
   }
 
-  Object* GetThreadGroup(const ScopedJniThreadState& ts) const;
+  bool HasPeer() const {
+    return peer_ != NULL;
+  }
+
+  Object* GetThreadGroup(const ScopedObjectAccessUnchecked& ts) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   RuntimeStats* GetStats() {
     return &stats_;
   }
 
-  int GetSuspendCount() const {
-    return suspend_count_;
-  }
-
   bool IsStillStarting() const;
 
   bool IsExceptionPending() const {
     return exception_ != NULL;
   }
 
-  Throwable* GetException() const {
+  Throwable* GetException() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(CanAccessDirectReferences());
     return exception_;
   }
 
-  void SetException(Throwable* new_exception) {
+  void AssertNoPendingException() const;
+
+  void SetException(Throwable* new_exception)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(CanAccessDirectReferences());
     CHECK(new_exception != NULL);
     // TODO: CHECK(exception_ == NULL);
@@ -252,7 +332,7 @@
   }
 
   // Find catch block and perform long jump to appropriate exception handle
-  void DeliverException();
+  void DeliverException() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Context* GetLongJumpContext();
   void ReleaseLongJumpContext(Context* context) {
@@ -260,7 +340,8 @@
     long_jump_context_ = context;
   }
 
-  Method* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const;
+  Method* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void SetTopOfStack(void* stack, uintptr_t pc) {
     Method** top_method = reinterpret_cast<Method**>(stack);
@@ -273,20 +354,25 @@
   }
 
   // If 'msg' is NULL, no detail message is set.
-  void ThrowNewException(const char* exception_class_descriptor, const char* msg);
+  void ThrowNewException(const char* exception_class_descriptor, const char* msg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // If 'msg' is NULL, no detail message is set. An exception must be pending, and will be
   // used as the new exception's cause.
-  void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg);
+  void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
-      __attribute__((format(printf, 3, 4)));
+      __attribute__((format(printf, 3, 4)))
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap);
+  void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // OutOfMemoryError is special, because we need to pre-allocate an instance.
   // Only the GC should call this.
-  void ThrowOutOfMemoryError(const char* msg);
+  void ThrowOutOfMemoryError(const char* msg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   //QuickFrameIterator FindExceptionHandler(void* throw_pc, void** handler_pc);
 
@@ -305,7 +391,10 @@
   }
 
   // Convert a jobject into a Object*
-  Object* DecodeJObject(jobject obj);
+  Object* DecodeJObject(jobject obj)
+      LOCKS_EXCLUDED(JavaVMExt::globals_lock,
+                     JavaVMExt::weak_globals_lock)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Implements java.lang.Thread.interrupted.
   bool Interrupted() {
@@ -335,9 +424,9 @@
     NotifyLocked();
   }
 
-  ClassLoader* GetClassLoaderOverride() {
-    // TODO: need to place the class_loader_override_ in a handle
-    // DCHECK(CanAccessDirectReferences());
+  ClassLoader* GetClassLoaderOverride()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    DCHECK(CanAccessDirectReferences());
     return class_loader_override_;
   }
 
@@ -347,7 +436,8 @@
 
   // Create the internal representation of a stack trace, that is more time
   // and space efficient to compute than the StackTraceElement[]
-  jobject CreateInternalStackTrace(const ScopedJniThreadState& ts) const;
+  jobject CreateInternalStackTrace(const ScopedObjectAccess& soa) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
   // StackTraceElement[]. If output_array is NULL, a new array is created, otherwise as many
@@ -356,7 +446,8 @@
   static jobjectArray InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
       jobjectArray output_array = NULL, int* stack_depth = NULL);
 
-  void VisitRoots(Heap::RootVisitor* visitor, void* arg);
+  void VisitRoots(Heap::RootVisitor* visitor, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 #if VERIFY_OBJECT_ENABLED
   void VerifyStack();
@@ -398,16 +489,7 @@
   }
 
   // Set the stack end to that to be used during a stack overflow
-  void SetStackEndForStackOverflow() {
-    // During stack overflow we allow use of the full stack
-    if (stack_end_ == stack_begin_) {
-      DumpStack(std::cerr);
-      LOG(FATAL) << "Need to increase kStackOverflowReservedBytes (currently "
-                 << kStackOverflowReservedBytes << ")";
-    }
-
-    stack_end_ = stack_begin_;
-  }
+  void SetStackEndForStackOverflow() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Set the stack end to that to be used during regular execution
   void ResetDefaultStackEnd() {
@@ -508,8 +590,13 @@
     return frame;
   }
 
-  void CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking);
-  void CheckSafeToWait(MutexRank rank);
+  BaseMutex* GetHeldMutex(MutexLevel level) const {
+    return held_mutexes_[level];
+  }
+
+  void SetHeldMutex(MutexLevel level, BaseMutex* mutex) {
+    held_mutexes_[level] = mutex;
+  }
 
  private:
   // We have no control over the size of 'bool', but want our boolean fields
@@ -517,24 +604,36 @@
   typedef uint32_t bool32_t;
 
   explicit Thread(bool daemon);
-  ~Thread();
+  ~Thread() LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                           GlobalSynchronization::thread_suspend_count_lock_);
   void Destroy();
   friend class ThreadList;  // For ~Thread and Destroy.
 
   void CreatePeer(const char* name, bool as_daemon, jobject thread_group);
   friend class Runtime; // For CreatePeer.
 
+  // TODO: remove, callers should use GetState and hold the appropriate locks. Used only by
+  //       ShortDump.
+  ThreadState GetStateUnsafe() const NO_THREAD_SAFETY_ANALYSIS {
+    return state_;
+  }
+
   void DumpState(std::ostream& os) const;
-  void DumpStack(std::ostream& os) const;
+  void DumpStack(std::ostream& os) const
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Out-of-line conveniences for debugging in gdb.
   static Thread* CurrentFromGdb(); // Like Thread::Current.
-  void DumpFromGdb() const; // Like Thread::Dump(std::cerr).
+  // Like Thread::Dump(std::cerr).
+  void DumpFromGdb() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static void* CreateCallback(void* arg);
 
-  void HandleUncaughtExceptions(const ScopedJniThreadState& ts);
-  void RemoveFromThreadGroup(const ScopedJniThreadState& ts);
+  void HandleUncaughtExceptions(const ScopedObjectAccess& soa)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void RemoveFromThreadGroup(const ScopedObjectAccess& soa)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void Init();
   void InitCardTable();
@@ -544,7 +643,7 @@
   void InitPthreadKeySelf();
   void InitStackHwm();
 
-  void NotifyLocked() {
+  void NotifyLocked() EXCLUSIVE_LOCKS_REQUIRED(wait_mutex_) {
     if (wait_monitor_ != NULL) {
       wait_cond_->Signal();
     }
@@ -555,11 +654,16 @@
   // TLS key used to retrieve the Thread*.
   static pthread_key_t pthread_key_self_;
 
+  // Used to notify threads that they should attempt to resume, they will suspend again if
+  // their suspend count is > 0.
+  static ConditionVariable* resume_cond_
+      GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
+
   // --- Frequently accessed fields first for short offsets ---
 
   // A non-zero value is used to tell the current thread to enter a safe point
   // at the next poll.
-  int suspend_count_;
+  int suspend_count_ GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
 
   // The biased card table, see CardTable for details
   byte* card_table_;
@@ -582,7 +686,7 @@
   // is hard. This field can be read off of Thread::Current to give the address.
   Thread* self_;
 
-  volatile ThreadState state_;
+  volatile ThreadState state_ GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
 
   // Our managed peer (an instance of java.lang.Thread).
   Object* peer_;
@@ -604,12 +708,12 @@
   pid_t tid_;
 
   // Guards the 'interrupted_' and 'wait_monitor_' members.
-  mutable Mutex* wait_mutex_;
-  ConditionVariable* wait_cond_;
-  // Pointer to the monitor lock we're currently waiting on (or NULL), guarded by wait_mutex_.
-  Monitor* wait_monitor_;
-  // Thread "interrupted" status; stays raised until queried or thrown, guarded by wait_mutex_.
-  bool32_t interrupted_;
+  mutable Mutex* wait_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  ConditionVariable* wait_cond_ GUARDED_BY(wait_mutex_);
+  // Pointer to the monitor lock we're currently waiting on (or NULL).
+  Monitor* wait_monitor_ GUARDED_BY(wait_mutex_);
+  // Thread "interrupted" status; stays raised until queried or thrown.
+  bool32_t interrupted_ GUARDED_BY(wait_mutex_);
   // The next thread in the wait set this thread is part of.
   Thread* wait_next_;
   // If we're blocked in MonitorEnter, this is the object we're trying to lock.
@@ -636,7 +740,7 @@
 
   // How much of 'suspend_count_' is by request of the debugger, used to set things right
   // when the debugger detaches. Must be <= suspend_count_.
-  int debug_suspend_count_;
+  int debug_suspend_count_ GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
 
   // JDWP invoke-during-breakpoint support.
   DebugInvokeReq* debug_invoke_req_;
@@ -654,8 +758,8 @@
   // A cached pthread_t for the pthread underlying this Thread*.
   pthread_t pthread_self_;
 
-  // Mutexes held by this thread, see CheckSafeToLockOrUnlock.
-  uint32_t held_mutexes_[kMaxMutexRank + 1];
+  // Support for Mutex lock hierarchy bug detection.
+  BaseMutex* held_mutexes_[kMaxMutexLevel + 1];
 
   // A positive value implies we're in a region where thread suspension isn't expected.
   uint32_t no_thread_suspension_;
@@ -672,39 +776,12 @@
   // How many times has our pthread key's destructor been called?
   uint32_t thread_exit_check_count_;
 
-  friend class ScopedThreadListLockReleaser;
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 std::ostream& operator<<(std::ostream& os, const Thread& thread);
 std::ostream& operator<<(std::ostream& os, const ThreadState& state);
 
-class ScopedThreadStateChange {
- public:
-  ScopedThreadStateChange(Thread* thread, ThreadState new_state) : thread_(thread) {
-    if (thread_ == NULL) {
-      // Value chosen arbitrarily and won't be used in the destructor since thread_ == NULL.
-      old_thread_state_ = kTerminated;
-      CHECK(Runtime::Current()->IsShuttingDown());
-      return;
-    }
-    old_thread_state_ = thread_->SetState(new_state);
-  }
-
-  ~ScopedThreadStateChange() {
-    if (thread_ == NULL) {
-      CHECK(Runtime::Current()->IsShuttingDown());
-      return;
-    }
-    thread_->SetState(old_thread_state_);
-  }
-
- private:
-  Thread* thread_;
-  ThreadState old_thread_state_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedThreadStateChange);
-};
-
 }  // namespace art
 
 #endif  // ART_SRC_THREAD_H_
diff --git a/src/thread_list.cc b/src/thread_list.cc
index ae74420..0bd587c 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -21,8 +21,6 @@
 #include <unistd.h>
 
 #include "debugger.h"
-#include "scoped_heap_lock.h"
-#include "scoped_thread_list_lock.h"
 #include "timing_logger.h"
 #include "utils.h"
 
@@ -30,11 +28,8 @@
 
 ThreadList::ThreadList()
     : allocated_ids_lock_("allocated thread ids lock"),
-      thread_list_lock_("thread list lock", kThreadListLock),
-      thread_start_cond_("thread start condition variable"),
-      thread_exit_cond_("thread exit condition variable"),
-      thread_suspend_count_lock_("thread suspend count lock", kThreadSuspendCountLock),
-      thread_suspend_count_cond_("thread suspend count condition variable") {
+      suspend_all_count_(0), debug_suspend_all_count_(0),
+      thread_exit_cond_("thread exit condition variable") {
 }
 
 ThreadList::~ThreadList() {
@@ -46,6 +41,8 @@
   }
 
   WaitForOtherNonDaemonThreadsToExit();
+  // TODO: there's an unaddressed race here where a thread may attach during shutdown, see
+  //       Thread::Init.
   SuspendAllDaemonThreads();
 }
 
@@ -63,12 +60,14 @@
 }
 
 pid_t ThreadList::GetLockOwner() {
-  return thread_list_lock_.GetOwner();
+  return GlobalSynchronization::thread_list_lock_->GetExclusiveOwnerTid();
 }
 
 void ThreadList::DumpForSigQuit(std::ostream& os) {
-  ScopedThreadListLock thread_list_lock;
-  DumpLocked(os);
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    DumpLocked(os);
+  }
   DumpUnattachedThreads(os);
 }
 
@@ -94,14 +93,22 @@
   while (!readdir_r(d, &de, &e) && e != NULL) {
     char* end;
     pid_t tid = strtol(de.d_name, &end, 10);
-    if (!*end && !Contains(tid)) {
-      DumpUnattachedThread(os, tid);
+    if (!*end) {
+      bool contains;
+      {
+        MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+        contains = Contains(tid);
+      }
+      if (!contains) {
+        DumpUnattachedThread(os, tid);
+      }
     }
   }
   closedir(d);
 }
 
 void ThreadList::DumpLocked(std::ostream& os) {
+  GlobalSynchronization::thread_list_lock_->AssertHeld();
   os << "DALVIK THREADS (" << list_.size() << "):\n";
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     (*it)->Dump(os);
@@ -109,119 +116,171 @@
   }
 }
 
-void ThreadList::ModifySuspendCount(Thread* thread, int delta, bool for_debugger) {
-#ifndef NDEBUG
-  DCHECK(delta == -1 || delta == +1 || delta == -thread->debug_suspend_count_)
-      << delta << " " << thread->debug_suspend_count_ << " " << *thread;
-  DCHECK_GE(thread->suspend_count_, thread->debug_suspend_count_) << *thread;
-#endif
-  if (delta == -1 && thread->suspend_count_ <= 0) {
-    // This is expected if you attach a thread during a GC.
-    if (UNLIKELY(!thread->IsStillStarting())) {
-      std::ostringstream ss;
-      Runtime::Current()->GetThreadList()->DumpLocked(ss);
-      LOG(FATAL) << *thread << " suspend count already zero.\n" << ss.str();
-    }
-    return;
-  }
-  thread->suspend_count_ += delta;
-  if (for_debugger) {
-    thread->debug_suspend_count_ += delta;
-  }
-}
-
-void ThreadList::FullSuspendCheck(Thread* thread) {
-  CHECK(thread != NULL);
-  CHECK_GE(thread->suspend_count_, 0);
-
-  MutexLock mu(thread_suspend_count_lock_);
-  if (thread->suspend_count_ == 0) {
-    return;
-  }
-
-  VLOG(threads) << *thread << " self-suspending";
-  {
-    ScopedThreadStateChange tsc(thread, kSuspended);
-    while (thread->suspend_count_ != 0) {
-      /*
-       * Wait for wakeup signal, releasing lock.  The act of releasing
-       * and re-acquiring the lock provides the memory barriers we
-       * need for correct behavior on SMP.
-       */
-      thread_suspend_count_cond_.Wait(thread_suspend_count_lock_);
-    }
-    CHECK_EQ(thread->suspend_count_, 0);
-  }
-  VLOG(threads) << *thread << " self-reviving";
-}
-
-void ThreadList::SuspendAll(bool for_debugger) {
-  Thread* self = Thread::Current();
-
-  VLOG(threads) << *self << " SuspendAll starting..." << (for_debugger ? " (debugger)" : "");
-
-  CHECK_EQ(self->GetState(), kRunnable);
-  ScopedThreadListLock thread_list_lock;
-  Thread* debug_thread = Dbg::GetDebugThread();
-  {
-    // Increment everybody's suspend count (except our own).
-    MutexLock mu(thread_suspend_count_lock_);
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
-      if (thread == self || (for_debugger && thread == debug_thread)) {
-        continue;
-      }
-      VLOG(threads) << "requesting thread suspend: " << *thread;
-      ModifySuspendCount(thread, +1, for_debugger);
-    }
-  }
-
-  /*
-   * Wait for everybody in kRunnable state to stop.  Other states
-   * indicate the code is either running natively or sleeping quietly.
-   * Any attempt to transition back to kRunnable will cause a check
-   * for suspension, so it should be impossible for anything to execute
-   * interpreted code or modify objects (assuming native code plays nicely).
-   *
-   * It's also okay if the thread transitions to a non-kRunnable state.
-   *
-   * Note we released the thread_suspend_count_lock_ before getting here,
-   * so if another thread is fiddling with its suspend count (perhaps
-   * self-suspending for the debugger) it won't block while we're waiting
-   * in here.
-   */
+void ThreadList::AssertThreadsAreSuspended() {
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     Thread* thread = *it;
-    if (thread == self || (for_debugger && thread == debug_thread)) {
-      continue;
-    }
-    thread->WaitUntilSuspended();
-    VLOG(threads) << "thread suspended: " << *thread;
+    CHECK_NE(thread->GetState(), kRunnable);
   }
+}
+
+// Attempt to rectify locks so that we dump thread list with required locks before exiting.
+static void UnsafeLogFatalForThreadSuspendAllTimeout() NO_THREAD_SAFETY_ANALYSIS {
+  Runtime* runtime = Runtime::Current();
+  std::ostringstream ss;
+  ss << "Thread suspend timeout\n";
+  runtime->DumpLockHolders(ss);
+  ss << "\n";
+  GlobalSynchronization::mutator_lock_->SharedTryLock();
+  if (!GlobalSynchronization::mutator_lock_->IsSharedHeld()) {
+    LOG(WARNING) << "Dumping thread list without holding mutator_lock_";
+  }
+  GlobalSynchronization::thread_list_lock_->TryLock();
+  if (!GlobalSynchronization::thread_list_lock_->IsExclusiveHeld()) {
+    LOG(WARNING) << "Dumping thread list without holding thread_list_lock_";
+  }
+  runtime->GetThreadList()->DumpLocked(ss);
+  LOG(FATAL) << ss.str();
+}
+
+void ThreadList::SuspendAll() {
+  Thread* self = Thread::Current();
+
+  VLOG(threads) << *self << " SuspendAll starting...";
+
+  if (kIsDebugBuild) {
+    GlobalSynchronization::mutator_lock_->AssertNotHeld();
+    GlobalSynchronization::thread_list_lock_->AssertNotHeld();
+    GlobalSynchronization::thread_suspend_count_lock_->AssertNotHeld();
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK_NE(self->GetState(), kRunnable);
+  }
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    {
+      MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+      // Update global suspend all state for attaching threads.
+      ++suspend_all_count_;
+      // Increment everybody's suspend count (except our own).
+      for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+        Thread* thread = *it;
+        if (thread == self) {
+          continue;
+        }
+        VLOG(threads) << "requesting thread suspend: " << *thread;
+        thread->ModifySuspendCount(+1, false);
+      }
+    }
+  }
+
+  // Block on the mutator lock until all Runnable threads release their share of access. Timeout
+  // if we wait more than 30 seconds.
+  timespec timeout;
+  clock_gettime(CLOCK_REALTIME, &timeout);
+  timeout.tv_sec += 30;
+  if (UNLIKELY(!GlobalSynchronization::mutator_lock_->ExclusiveLockWithTimeout(timeout))) {
+    UnsafeLogFatalForThreadSuspendAllTimeout();
+  }
+
+  // Debug check that all threads are suspended.
+  AssertThreadsAreSuspended();
 
   VLOG(threads) << *self << " SuspendAll complete";
 }
 
-void ThreadList::Suspend(Thread* thread, bool for_debugger) {
+void ThreadList::ResumeAll() {
+  Thread* self = Thread::Current();
+
+  VLOG(threads) << *self << " ResumeAll starting";
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+    // Update global suspend all state for attaching threads.
+    --suspend_all_count_;
+    // Decrement the suspend counts for all threads.
+    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+      Thread* thread = *it;
+      if (thread == self) {
+        continue;
+      }
+      thread->ModifySuspendCount(-1, false);
+    }
+
+    // Broadcast a notification to all suspended threads, some or all of
+    // which may choose to wake up.  No need to wait for them.
+    VLOG(threads) << *self << " ResumeAll waking others";
+    Thread::resume_cond_->Broadcast();
+  }
+  GlobalSynchronization::mutator_lock_->ExclusiveUnlock();
+  VLOG(threads) << *self << " ResumeAll complete";
+}
+
+void ThreadList::Resume(Thread* thread, bool for_debugger) {
   DCHECK(thread != Thread::Current());
-  thread_list_lock_.AssertHeld();
+  VLOG(threads) << "Resume(" << *thread << ") starting..." << (for_debugger ? " (debugger)" : "");
 
-  // TODO: add another thread_suspend_lock_ to avoid GC/debugger races.
-
-  VLOG(threads) << "Suspend(" << *thread << ") starting..." << (for_debugger ? " (debugger)" : "");
-
-  if (!Contains(thread)) {
-    return;
+  {
+    // To check Contains.
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    // To check IsSuspended.
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+    CHECK(thread->IsSuspended());
+    if (!Contains(thread)) {
+      return;
+    }
+    thread->ModifySuspendCount(-1, for_debugger);
   }
 
   {
-    MutexLock mu(thread_suspend_count_lock_);
-    ModifySuspendCount(thread, +1, for_debugger);
+    VLOG(threads) << "Resume(" << *thread << ") waking others";
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    Thread::resume_cond_->Broadcast();
   }
 
-  thread->WaitUntilSuspended();
+  VLOG(threads) << "Resume(" << *thread << ") complete";
+}
 
-  VLOG(threads) << "Suspend(" << *thread << ") complete";
+void ThreadList::SuspendAllForDebugger() {
+  Thread* self = Thread::Current();
+  Thread* debug_thread = Dbg::GetDebugThread();
+
+  VLOG(threads) << *self << " SuspendAllForDebugger starting...";
+
+  {
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    {
+      MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+      // Update global suspend all state for attaching threads.
+      ++suspend_all_count_;
+      ++debug_suspend_all_count_;
+      // Increment everybody's suspend count (except our own).
+      for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+        Thread* thread = *it;
+        if (thread == self || thread == debug_thread) {
+          continue;
+        }
+        VLOG(threads) << "requesting thread suspend: " << *thread;
+        thread->ModifySuspendCount(+1, true);
+      }
+    }
+  }
+
+  // Block on the mutator lock until all Runnable threads release their share of access. Timeout
+  // if we wait more than 30 seconds.
+  timespec timeout;
+  clock_gettime(CLOCK_REALTIME, &timeout);
+  timeout.tv_sec += 30;
+  if (!GlobalSynchronization::mutator_lock_->ExclusiveLockWithTimeout(timeout)) {
+    UnsafeLogFatalForThreadSuspendAllTimeout();
+  } else {
+    // Debugger suspends all threads but doesn't hold onto the mutator_lock_.
+    GlobalSynchronization::mutator_lock_->ExclusiveUnlock();
+  }
+
+  AssertThreadsAreSuspended();
+
+  VLOG(threads) << *self << " SuspendAll complete";
 }
 
 void ThreadList::SuspendSelfForDebugger() {
@@ -235,8 +294,8 @@
   // Collisions with other suspends aren't really interesting. We want
   // to ensure that we're the only one fiddling with the suspend count
   // though.
-  MutexLock mu(thread_suspend_count_lock_);
-  ModifySuspendCount(self, +1, true);
+  MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+  self->ModifySuspendCount(+1, true);
 
   // Suspend ourselves.
   CHECK_GT(self->suspend_count_, 0);
@@ -249,7 +308,7 @@
   Dbg::ClearWaitForEventThread();
 
   while (self->suspend_count_ != 0) {
-    thread_suspend_count_cond_.Wait(thread_suspend_count_lock_);
+    Thread::resume_cond_->Wait(*GlobalSynchronization::thread_suspend_count_lock_);
     if (self->suspend_count_ != 0) {
       // The condition was signaled but we're still suspended. This
       // can happen if the debugger lets go while a SIGQUIT thread
@@ -264,255 +323,71 @@
   VLOG(threads) << *self << " self-reviving (debugger)";
 }
 
-void ThreadList::ResumeAll(bool for_debugger) {
-  Thread* self = Thread::Current();
-
-  VLOG(threads) << *self << " ResumeAll starting" << (for_debugger ? " (debugger)" : "");
-
-  // Decrement the suspend counts for all threads.  No need for atomic
-  // writes, since nobody should be moving until we decrement the count.
-  // We do need to hold the thread list because of JNI attaches.
-  {
-    ScopedThreadListLock thread_list_lock;
-    Thread* debug_thread = Dbg::GetDebugThread();
-    MutexLock mu(thread_suspend_count_lock_);
-    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-      Thread* thread = *it;
-      if (thread == self || (for_debugger && thread == debug_thread)) {
-        continue;
-      }
-      ModifySuspendCount(thread, -1, for_debugger);
-    }
-  }
-
-  // Broadcast a notification to all suspended threads, some or all of
-  // which may choose to wake up.  No need to wait for them.
-  {
-    VLOG(threads) << *self << " ResumeAll waking others";
-    MutexLock mu(thread_suspend_count_lock_);
-    thread_suspend_count_cond_.Broadcast();
-  }
-
-  VLOG(threads) << *self << " ResumeAll complete";
-}
-
-void ThreadList::Resume(Thread* thread, bool for_debugger) {
-  DCHECK(thread != Thread::Current());
-
-  if (!for_debugger) { // The debugger is very naughty. See Dbg::InvokeMethod.
-    thread_list_lock_.AssertHeld();
-  }
-
-  VLOG(threads) << "Resume(" << *thread << ") starting..." << (for_debugger ? " (debugger)" : "");
-
-  {
-    MutexLock mu(thread_suspend_count_lock_);
-    if (!Contains(thread)) {
-      return;
-    }
-    ModifySuspendCount(thread, -1, for_debugger);
-  }
-
-  {
-    VLOG(threads) << "Resume(" << *thread << ") waking others";
-    MutexLock mu(thread_suspend_count_lock_);
-    thread_suspend_count_cond_.Broadcast();
-  }
-
-  VLOG(threads) << "Resume(" << *thread << ") complete";
-}
-
-void ThreadList::RunWhileSuspended(Thread* thread, void (*callback)(void*), void* arg) {  // NOLINT
-  DCHECK(thread != NULL);
-  Thread* self = Thread::Current();
-  if (thread != self) {
-    Suspend(thread);
-  }
-  callback(arg);
-  if (thread != self) {
-    Resume(thread);
-  }
-}
-
 void ThreadList::UndoDebuggerSuspensions() {
   Thread* self = Thread::Current();
 
   VLOG(threads) << *self << " UndoDebuggerSuspensions starting";
 
   {
-    ScopedThreadListLock thread_list_lock;
-    MutexLock mu(thread_suspend_count_lock_);
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+    // Update global suspend all state for attaching threads.
+    suspend_all_count_ -= debug_suspend_all_count_;
+    debug_suspend_all_count_ = 0;
+    // Update running threads.
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
       if (thread == self || thread->debug_suspend_count_ == 0) {
         continue;
       }
-      ModifySuspendCount(thread, -thread->debug_suspend_count_, true);
+      thread->ModifySuspendCount(-thread->debug_suspend_count_, true);
     }
   }
 
   {
-    MutexLock mu(thread_suspend_count_lock_);
-    thread_suspend_count_cond_.Broadcast();
+    MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
+    Thread::resume_cond_->Broadcast();
   }
 
   VLOG(threads) << "UndoDebuggerSuspensions(" << *self << ") complete";
 }
 
-void ThreadList::Register() {
-  Thread* self = Thread::Current();
-
-  VLOG(threads) << "ThreadList::Register() " << *self << "\n" << Dumpable<Thread>(*self);
-
-  ScopedThreadListLock thread_list_lock;
-  CHECK(!Contains(self));
-  list_.push_back(self);
-}
-
-void ThreadList::Unregister() {
-  Thread* self = Thread::Current();
-
-  VLOG(threads) << "ThreadList::Unregister() " << *self;
-
-  // Any time-consuming destruction, plus anything that can call back into managed code or
-  // suspend and so on, must happen at this point, and not in ~Thread.
-  self->Destroy();
-
-  {
-    // Remove this thread from the list.
-    ScopedThreadListLock thread_list_lock;
-    CHECK(Contains(self));
-    list_.remove(self);
-  }
-
-  // Delete the Thread* and release the thin lock id.
-  uint32_t thin_lock_id = self->thin_lock_id_;
-  delete self;
-  ReleaseThreadId(thin_lock_id);
-
-  // Clear the TLS data, so that the underlying native thread is recognizably detached.
-  // (It may wish to reattach later.)
-  CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self");
-
-  // Signal that a thread just detached.
-  thread_exit_cond_.Signal();
-}
-
-void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
-  ScopedThreadListLock thread_list_lock;
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    callback(*it, context);
-  }
-}
-
-void ThreadList::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
-  ScopedThreadListLock thread_list_lock;
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    (*it)->VisitRoots(visitor, arg);
-  }
-}
-
-/*
- * Tell a new thread it's safe to start.
- *
- * We must hold the thread list lock before messing with another thread.
- * In the general case we would also need to verify that the new thread was
- * still in the thread list, but in our case the thread has not started
- * executing user code and therefore has not had a chance to exit.
- *
- * We move it to kVmWait, and it then shifts itself to kRunning, which
- * comes with a suspend-pending check. We do this after
- */
-void ThreadList::SignalGo(Thread* child) {
-  Thread* self = Thread::Current();
-  CHECK(child != self);
-
-  {
-    ScopedThreadListLock thread_list_lock;
-    VLOG(threads) << *self << " waiting for child " << *child << " to be in thread list...";
-
-    // We wait for the child to tell us that it's in the thread list.
-    while (child->GetState() != kStarting) {
-      thread_start_cond_.Wait(thread_list_lock_);
-    }
-  }
-
-  // If we switch out of runnable and then back in, we know there's no pending suspend.
-  self->SetState(kVmWait);
-  self->SetState(kRunnable);
-
-  // Tell the child that it's safe: it will see any future suspend request.
-  ScopedThreadListLock thread_list_lock;
-  VLOG(threads) << *self << " telling child " << *child << " it's safe to proceed...";
-  child->SetState(kVmWait);
-  thread_start_cond_.Broadcast();
-}
-
-void ThreadList::WaitForGo() {
-  Thread* self = Thread::Current();
-
-  {
-    ScopedThreadListLock thread_list_lock;
-    DCHECK(Contains(self));
-
-    // Tell our parent that we're in the thread list.
-    VLOG(threads) << *self << " telling parent that we're now in thread list...";
-    self->SetState(kStarting);
-    thread_start_cond_.Broadcast();
-
-    // Wait until our parent tells us there's no suspend still pending
-    // from before we were on the thread list.
-    VLOG(threads) << *self << " waiting for parent's go-ahead...";
-    while (self->GetState() != kVmWait) {
-      thread_start_cond_.Wait(thread_list_lock_);
-    }
-  }
-
-  // Enter the runnable state. We know that any pending suspend will affect us now.
-  VLOG(threads) << *self << " entering runnable state...";
-  // Lock and unlock the heap lock. This ensures that if there was a GC in progress when we
-  // started, we wait until it's over. Which means that if there's now another GC pending, our
-  // suspend count is non-zero, so switching to the runnable state will suspend us.
-  // TODO: find a better solution!
-  {
-    ScopedHeapLock heap_lock;
-  }
-  self->SetState(kRunnable);
-}
-
-bool ThreadList::AllOtherThreadsAreDaemons() {
-  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
-    // TODO: there's a race here with thread exit that's being worked around by checking if the peer
-    // is null.
-    Thread* thread = *it;
-    if (thread != Thread::Current() && thread->GetPeer() != NULL && !thread->IsDaemon()) {
-      return false;
-    }
-  }
-  return true;
-}
-
 void ThreadList::WaitForOtherNonDaemonThreadsToExit() {
-  ScopedThreadListLock thread_list_lock;
-  while (!AllOtherThreadsAreDaemons()) {
-    thread_exit_cond_.Wait(thread_list_lock_);
-  }
+  GlobalSynchronization::mutator_lock_->AssertNotHeld();
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  bool all_threads_are_daemons;
+  do {
+    all_threads_are_daemons = true;
+    for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+      // TODO: there's a race here with thread exit that's being worked around by checking if the
+      // thread has a peer.
+      Thread* thread = *it;
+      if (thread != Thread::Current() && thread->HasPeer() && !thread->IsDaemon()) {
+        all_threads_are_daemons = false;
+        break;
+      }
+    }
+    if (!all_threads_are_daemons) {
+      // Wait for another thread to exit before re-checking.
+      thread_exit_cond_.Wait(*GlobalSynchronization::thread_list_lock_);
+    }
+  } while(!all_threads_are_daemons);
 }
 
 void ThreadList::SuspendAllDaemonThreads() {
-  ScopedThreadListLock thread_list_lock;
-
-  // Tell all the daemons it's time to suspend.
-  {
-    MutexLock mu(thread_suspend_count_lock_);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  { // Tell all the daemons it's time to suspend.
+    MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
+      // This is only run after all non-daemon threads have exited, so the remainder should all be
+      // daemons.
+      CHECK(thread->IsDaemon());
       if (thread != Thread::Current()) {
         ++thread->suspend_count_;
       }
     }
   }
-
   // Give the threads a chance to suspend, complaining if they're slow.
   bool have_complained = false;
   for (int i = 0; i < 10; ++i) {
@@ -520,6 +395,7 @@
     bool all_suspended = true;
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
+      MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
       if (thread != Thread::Current() && thread->GetState() == kRunnable) {
         if (!have_complained) {
           LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
@@ -532,11 +408,72 @@
       return;
     }
   }
+  LOG(ERROR) << "suspend all daemons failed";
+}
+void ThreadList::Register(Thread* self) {
+  DCHECK_EQ(self, Thread::Current());
+
+  if (VLOG_IS_ON(threads)) {
+    std::ostringstream oss;
+    self->ShortDump(oss);  // We don't hold the mutator_lock_ yet and so cannot call Dump.
+    LOG(INFO) << "ThreadList::Register() " << *self  << "\n" << oss;
+  }
+
+  // Atomically add self to the thread list and make its thread_suspend_count_ reflect ongoing
+  // SuspendAll requests.
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  MutexLock mu2(*GlobalSynchronization::thread_suspend_count_lock_);
+  self->suspend_count_ = suspend_all_count_;
+  self->debug_suspend_count_ = debug_suspend_all_count_;
+  CHECK(!Contains(self));
+  list_.push_back(self);
+}
+
+void ThreadList::Unregister(Thread* self) {
+  DCHECK_EQ(self, Thread::Current());
+
+  VLOG(threads) << "ThreadList::Unregister() " << *self;
+
+  // Any time-consuming destruction, plus anything that can call back into managed code or
+  // suspend and so on, must happen at this point, and not in ~Thread.
+  self->Destroy();
+
+  {
+    // Remove this thread from the list.
+    MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+    CHECK(Contains(self));
+    list_.remove(self);
+  }
+
+  // Delete the Thread* and release the thin lock id.
+  uint32_t thin_lock_id = self->thin_lock_id_;
+  ReleaseThreadId(thin_lock_id);
+  delete self;
+
+  // Clear the TLS data, so that the underlying native thread is recognizably detached.
+  // (It may wish to reattach later.)
+  CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, NULL), "detach self");
+
+  // Signal that a thread just detached.
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  thread_exit_cond_.Signal();
+}
+
+void ThreadList::ForEach(void (*callback)(Thread*, void*), void* context) {
+  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+    callback(*it, context);
+  }
+}
+
+void ThreadList::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
+  for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
+    (*it)->VisitRoots(visitor, arg);
+  }
 }
 
 uint32_t ThreadList::AllocThreadId() {
   MutexLock mu(allocated_ids_lock_);
-  //ScopedThreadListLock thread_list_lock;
   for (size_t i = 0; i < allocated_ids_.size(); ++i) {
     if (!allocated_ids_[i]) {
       allocated_ids_.set(i);
diff --git a/src/thread_list.h b/src/thread_list.h
index ef475fe..e5b9114 100644
--- a/src/thread_list.h
+++ b/src/thread_list.h
@@ -33,66 +33,98 @@
   explicit ThreadList();
   ~ThreadList();
 
-  void DumpForSigQuit(std::ostream& os);
-  void DumpLocked(std::ostream& os); // For thread suspend timeout dumps.
+  void DumpForSigQuit(std::ostream& os)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void DumpLocked(std::ostream& os)  // For thread suspend timeout dumps.
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_list_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   pid_t GetLockOwner(); // For SignalCatcher.
 
   // Thread suspension support.
-  void FullSuspendCheck(Thread* thread);
-  void ResumeAll(bool for_debugger = false);
-  void Resume(Thread* thread, bool for_debugger = false);
-  void RunWhileSuspended(Thread* thread, void (*callback)(void*), void* arg);  // NOLINT
-  void SuspendAll(bool for_debugger = false);
-  void SuspendSelfForDebugger();
-  void Suspend(Thread* thread, bool for_debugger = false);
-  void UndoDebuggerSuspensions();
+  void ResumeAll()
+      UNLOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+  void Resume(Thread* thread, bool for_debugger = false)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_);
+
+  // Suspends all threads and gets exclusive access to the mutator_lock_.
+  void SuspendAll()
+      EXCLUSIVE_LOCK_FUNCTION(GlobalSynchronization::mutator_lock_)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+
+  // Suspends all threads
+  void SuspendAllForDebugger()
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+
+  void SuspendSelfForDebugger()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_suspend_count_lock_);
+
+  void UndoDebuggerSuspensions()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
 
   // Iterates over all the threads.
-  void ForEach(void (*callback)(Thread*, void*), void* context);
+  void ForEach(void (*callback)(Thread*, void*), void* context)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_list_lock_);
 
-  void Register();
-  void Unregister();
+  // Add/remove current thread from list.
+  void Register(Thread* self)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_list_lock_);
+  void Unregister(Thread* self)
+      LOCKS_EXCLUDED(GlobalSynchronization::mutator_lock_,
+                     GlobalSynchronization::thread_list_lock_);
 
-  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
+  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  // Handshaking for new thread creation.
-  void SignalGo(Thread* child);
-  void WaitForGo();
+  // Return a copy of the thread list.
+  std::list<Thread*> GetList() EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_list_lock_) {
+    return list_;
+  }
 
  private:
   typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
 
   uint32_t AllocThreadId();
-  void ReleaseThreadId(uint32_t id);
+  void ReleaseThreadId(uint32_t id) LOCKS_EXCLUDED(allocated_ids_lock_);
 
-  bool Contains(Thread* thread);
-  bool Contains(pid_t tid);
+  bool Contains(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_list_lock_);
+  bool Contains(pid_t tid) EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::thread_list_lock_);
 
-  void DumpUnattachedThreads(std::ostream& os);
+  void DumpUnattachedThreads(std::ostream& os)
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_);
 
-  bool AllOtherThreadsAreDaemons();
-  void SuspendAllDaemonThreads();
-  void WaitForOtherNonDaemonThreadsToExit();
+  void SuspendAllDaemonThreads()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
+  void WaitForOtherNonDaemonThreadsToExit()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
 
-  static void ModifySuspendCount(Thread* thread, int delta, bool for_debugger);
+  void AssertThreadsAreSuspended()
+      LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_,
+                     GlobalSynchronization::thread_suspend_count_lock_);
 
-  mutable Mutex allocated_ids_lock_;
+  mutable Mutex allocated_ids_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   std::bitset<kMaxThreadId> allocated_ids_ GUARDED_BY(allocated_ids_lock_);
 
-  mutable Mutex thread_list_lock_;
-  std::list<Thread*> list_; // TODO: GUARDED_BY(thread_list_lock_);
+  // The actual list of all threads.
+  std::list<Thread*> list_ GUARDED_BY(GlobalSynchronization::thread_list_lock_);
 
-  ConditionVariable thread_start_cond_;
-  ConditionVariable thread_exit_cond_;
+  // Ongoing suspend all requests, used to ensure threads added to list_ respect SuspendAll.
+  int suspend_all_count_ GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
+  int debug_suspend_all_count_ GUARDED_BY(GlobalSynchronization::thread_suspend_count_lock_);
 
-  // This lock guards every thread's suspend_count_ field...
-  mutable Mutex thread_suspend_count_lock_;
-  // ...and is used in conjunction with this condition variable.
-  ConditionVariable thread_suspend_count_cond_ GUARDED_BY(thread_suspend_count_lock_);
+  // Signaled when threads terminate. Used to determine when all non-daemons have terminated.
+  ConditionVariable thread_exit_cond_ GUARDED_BY(GlobalSynchronization::thread_list_lock_);
 
   friend class Thread;
-  friend class ScopedThreadListLock;
-  friend class ScopedThreadListLockReleaser;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadList);
 };
diff --git a/src/trace.cc b/src/trace.cc
index cd594cf..5ac7e3d 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -26,7 +26,7 @@
 #endif
 #include "object_utils.h"
 #include "os.h"
-#include "scoped_thread_list_lock.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "thread_list.h"
 
@@ -158,7 +158,8 @@
   *buf++ = (uint8_t) (val >> 56);
 }
 
-static bool InstallStubsClassVisitor(Class* klass, void*) {
+static bool InstallStubsClassVisitor(Class* klass, void*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Trace* tracer = Runtime::Current()->GetTracer();
   for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
     Method* method = klass->GetDirectMethod(i);
@@ -176,7 +177,8 @@
   return true;
 }
 
-static bool UninstallStubsClassVisitor(Class* klass, void*) {
+static bool UninstallStubsClassVisitor(Class* klass, void*)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   Trace* tracer = Runtime::Current()->GetTracer();
   for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
     Method* method = klass->GetDirectMethod(i);
@@ -214,6 +216,7 @@
 
     Thread* self_;
   };
+  ScopedObjectAccess soa(self);
   RestoreStackVisitor visitor(self);
   visitor.WalkStack();
 }
@@ -266,7 +269,7 @@
   }
 
   ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
-  Runtime::Current()->GetThreadList()->SuspendAll(false);
+  Runtime::Current()->GetThreadList()->SuspendAll();
 
   // Open trace file if not going directly to ddms.
   File* trace_file = NULL;
@@ -280,7 +283,7 @@
       PLOG(ERROR) << "Unable to open trace file '" << trace_filename << "'";
       Thread::Current()->ThrowNewException("Ljava/lang/RuntimeException;",
           StringPrintf("Unable to open trace file '%s'", trace_filename).c_str());
-      Runtime::Current()->GetThreadList()->ResumeAll(false);
+      Runtime::Current()->GetThreadList()->ResumeAll();
       return;
     }
   }
@@ -296,7 +299,7 @@
   Runtime::Current()->EnableMethodTracing(tracer);
   tracer->BeginTracing();
 
-  Runtime::Current()->GetThreadList()->ResumeAll(false);
+  Runtime::Current()->GetThreadList()->ResumeAll();
 }
 
 void Trace::Stop() {
@@ -306,12 +309,12 @@
   }
 
   ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
-  Runtime::Current()->GetThreadList()->SuspendAll(false);
+  Runtime::Current()->GetThreadList()->SuspendAll();
 
   Runtime::Current()->GetTracer()->FinishTracing();
   Runtime::Current()->DisableMethodTracing();
 
-  Runtime::Current()->GetThreadList()->ResumeAll(false);
+  Runtime::Current()->GetThreadList()->ResumeAll();
 }
 
 void Trace::Shutdown() {
@@ -486,6 +489,8 @@
 }
 
 void Trace::DumpThreadList(std::ostream& os) {
+  GlobalSynchronization::thread_list_lock_->AssertNotHeld();
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(DumpThread, &os);
 }
 
@@ -494,7 +499,9 @@
 }
 
 void Trace::UninstallStubs() {
+  GlobalSynchronization::thread_list_lock_->AssertNotHeld();
   Runtime::Current()->GetClassLinker()->VisitClasses(UninstallStubsClassVisitor, NULL);
+  MutexLock mu(*GlobalSynchronization::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(TraceRestoreStack, NULL);
 }
 
diff --git a/src/trace.h b/src/trace.h
index 0042fc2..c60ae15 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -65,7 +65,7 @@
 
   static void Start(const char* trace_filename, int trace_fd, int buffer_size, int flags, bool direct_to_ddms);
   static void Stop();
-  static void Shutdown();
+  static void Shutdown() NO_THREAD_SAFETY_ANALYSIS;  // TODO: implement appropriate locking.
 
   bool UseWallClock();
   bool UseThreadCpuClock();
@@ -83,18 +83,18 @@
   explicit Trace(File* trace_file, int buffer_size, int flags);
 
   void BeginTracing();
-  void FinishTracing();
+  void FinishTracing() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Replaces code of each method with a pointer to a stub for method tracing.
   void InstallStubs();
 
   // Restores original code for each method and fixes the return values of each thread's stack.
-  void UninstallStubs();
+  void UninstallStubs() LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_);
 
   // Methods to output traced methods and threads.
   void GetVisitedMethods(size_t end_offset);
-  void DumpMethodList(std::ostream& os);
-  void DumpThreadList(std::ostream& os);
+  void DumpMethodList(std::ostream& os) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(GlobalSynchronization::thread_list_lock_);
 
   // Maps a method to its original code pointer.
   SafeMap<const Method*, const void*> saved_code_map_;
diff --git a/src/utf.h b/src/utf.h
index 0758896..dd5791c 100644
--- a/src/utf.h
+++ b/src/utf.h
@@ -19,6 +19,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include "macros.h"
 
 /*
  * All UTF-8 in art is actually modified UTF-8. Mostly, this distinction
@@ -63,7 +64,8 @@
 /*
  * The java.lang.String hashCode() algorithm.
  */
-int32_t ComputeUtf16Hash(const CharArray* chars, int32_t offset, size_t char_count);
+int32_t ComputeUtf16Hash(const CharArray* chars, int32_t offset, size_t char_count)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 int32_t ComputeUtf16Hash(const uint16_t* chars, size_t char_count);
 
 /*
diff --git a/src/utils.h b/src/utils.h
index a31588b..851c6b1 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -167,30 +167,36 @@
 std::string PrettyDescriptor(const String* descriptor);
 std::string PrettyDescriptor(const std::string& descriptor);
 std::string PrettyDescriptor(Primitive::Type type);
-std::string PrettyDescriptor(const Class* klass);
+std::string PrettyDescriptor(const Class* klass)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
 // "int a.b.C.f" (depending on the value of 'with_type').
-std::string PrettyField(const Field* f, bool with_type = true);
+std::string PrettyField(const Field* f, bool with_type = true)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
 
 // Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
 // "a.b.C.m(II)V" (depending on the value of 'with_signature').
-std::string PrettyMethod(const Method* m, bool with_signature = true);
+std::string PrettyMethod(const Method* m, bool with_signature = true)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
 
 // Returns a human-readable form of the name of the *class* of the given object.
 // So given an instance of java.lang.String, the output would
 // be "java.lang.String". Given an array of int, the output would be "int[]".
 // Given String.class, the output would be "java.lang.Class<java.lang.String>".
-std::string PrettyTypeOf(const Object* obj);
+std::string PrettyTypeOf(const Object* obj)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Returns a human-readable form of the name of the given class.
 // Given String.class, the output would be "java.lang.Class<java.lang.String>".
-std::string PrettyClass(const Class* c);
+std::string PrettyClass(const Class* c)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Returns a human-readable form of the name of the given class with its class loader.
-std::string PrettyClassAndClassLoader(const Class* c);
+std::string PrettyClassAndClassLoader(const Class* c)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 // Returns a human-readable size string such as "1MB".
 std::string PrettySize(size_t size_in_bytes);
@@ -223,9 +229,11 @@
 bool IsValidMemberName(const char* s);
 
 // Returns the JNI native function name for the non-overloaded method 'm'.
-std::string JniShortName(const Method* m);
+std::string JniShortName(const Method* m)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 // Returns the JNI native function name for the overloaded method 'm'.
-std::string JniLongName(const Method* m);
+std::string JniLongName(const Method* m)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 bool ReadFileToString(const std::string& file_name, std::string* result);
 
diff --git a/src/utils_test.cc b/src/utils_test.cc
index 311bd16..e6ff118 100644
--- a/src/utils_test.cc
+++ b/src/utils_test.cc
@@ -16,6 +16,7 @@
 
 #include "object.h"
 #include "common_test.h"
+#include "scoped_thread_state_change.h"
 #include "utils.h"
 
 namespace art {
@@ -84,6 +85,7 @@
 }
 
 TEST_F(UtilsTest, PrettyTypeOf) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", PrettyTypeOf(NULL));
 
   SirtRef<String> s(String::AllocFromModifiedUtf8(""));
@@ -100,6 +102,7 @@
 }
 
 TEST_F(UtilsTest, PrettyClass) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", PrettyClass(NULL));
   Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
@@ -108,6 +111,7 @@
 }
 
 TEST_F(UtilsTest, PrettyClassAndClassLoader) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", PrettyClassAndClassLoader(NULL));
   Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
@@ -116,6 +120,7 @@
 }
 
 TEST_F(UtilsTest, PrettyField) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", PrettyField(NULL));
 
   Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
@@ -177,6 +182,7 @@
 }
 
 TEST_F(UtilsTest, MangleForJni) {
+  ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("hello_00024world", MangleForJni("hello$world"));
   EXPECT_EQ("hello_000a9world", MangleForJni("hello\xc2\xa9world"));
   EXPECT_EQ("hello_1world", MangleForJni("hello_world"));
@@ -185,6 +191,7 @@
 }
 
 TEST_F(UtilsTest, JniShortName_JniLongName) {
+  ScopedObjectAccess soa(Thread::Current());
   Class* c = class_linker_->FindSystemClass("Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
   Method* m;
diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index 5e98b1e..167e1e5 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -313,7 +313,7 @@
                           method, method->GetAccessFlags());
   verifier.Verify();
   verifier.DumpFailures(LOG(INFO) << "Dump of method " << PrettyMethod(method) << "\n")
-      << verifier.info_messages_.str() << Dumpable<MethodVerifier>(verifier);
+      << verifier.info_messages_.str() << MutatorLockedDumpable<MethodVerifier>(verifier);
 }
 
 MethodVerifier::MethodVerifier(const DexFile* dex_file, DexCache* dex_cache,
@@ -1026,7 +1026,8 @@
   return os;
 }
 
-extern "C" void MethodVerifierGdbDump(MethodVerifier* v) {
+extern "C" void MethodVerifierGdbDump(MethodVerifier* v)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   v->Dump(std::cerr);
 }
 
@@ -3327,13 +3328,15 @@
 }
 
 void MethodVerifier::SetGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map) {
-  MutexLock mu(*gc_maps_lock_);
-  GcMapTable::iterator it = gc_maps_->find(ref);
-  if (it != gc_maps_->end()) {
-    delete it->second;
-    gc_maps_->erase(it);
+  {
+    MutexLock mu(*gc_maps_lock_);
+    GcMapTable::iterator it = gc_maps_->find(ref);
+    if (it != gc_maps_->end()) {
+      delete it->second;
+      gc_maps_->erase(it);
+    }
+    gc_maps_->Put(ref, &gc_map);
   }
-  gc_maps_->Put(ref, &gc_map);
   CHECK(GetGcMap(ref) != NULL);
 }
 
@@ -3411,8 +3414,10 @@
 }
 
 void MethodVerifier::AddRejectedClass(Compiler::ClassReference ref) {
-  MutexLock mu(*rejected_classes_lock_);
-  rejected_classes_->insert(ref);
+  {
+    MutexLock mu(*rejected_classes_lock_);
+    rejected_classes_->insert(ref);
+  }
   CHECK(IsClassRejected(ref));
 }
 
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index b2a88b7..a67366f 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -162,10 +162,12 @@
   };
 
   /* Verify a class. Returns "kNoFailure" on success. */
-  static FailureKind VerifyClass(const Class* klass, std::string& error);
+  static FailureKind VerifyClass(const Class* klass, std::string& error)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   static FailureKind VerifyClass(const DexFile* dex_file, DexCache* dex_cache,
                                  ClassLoader* class_loader, uint32_t class_def_idx,
-                                 std::string& error);
+                                 std::string& error)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   uint8_t EncodePcToReferenceMapData() const;
 
@@ -191,13 +193,16 @@
 
   // Dump the state of the verifier, namely each instruction, what flags are set on it, register
   // information
-  void Dump(std::ostream& os);
+  void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  static const std::vector<uint8_t>* GetGcMap(Compiler::MethodReference ref);
+  static const std::vector<uint8_t>* GetGcMap(Compiler::MethodReference ref)
+      LOCKS_EXCLUDED(gc_maps_lock_);
 
   // Fills 'monitor_enter_dex_pcs' with the dex pcs of the monitor-enter instructions corresponding
   // to the locks held at 'dex_pc' in 'm'.
-  static void FindLocksAtDexPc(Method* m, uint32_t dex_pc, std::vector<uint32_t>& monitor_enter_dex_pcs);
+  static void FindLocksAtDexPc(Method* m, uint32_t dex_pc,
+                               std::vector<uint32_t>& monitor_enter_dex_pcs)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static void Init();
   static void Shutdown();
@@ -206,12 +211,14 @@
   static const InferredRegCategoryMap* GetInferredRegCategoryMap(Compiler::MethodReference ref);
 #endif
 
-  static bool IsClassRejected(Compiler::ClassReference ref);
+  static bool IsClassRejected(Compiler::ClassReference ref)
+      LOCKS_EXCLUDED(rejected_classes_lock_);
 
  private:
   explicit MethodVerifier(const DexFile* dex_file, DexCache* dex_cache,
       ClassLoader* class_loader, uint32_t class_def_idx, const DexFile::CodeItem* code_item,
-      uint32_t method_idx, Method* method, uint32_t access_flags);
+      uint32_t method_idx, Method* method, uint32_t access_flags)
+          SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Adds the given string to the beginning of the last failure message.
   void PrependToLastFailMessage(std::string);
@@ -232,14 +239,16 @@
    */
   static FailureKind VerifyMethod(uint32_t method_idx, const DexFile* dex_file, DexCache* dex_cache,
       ClassLoader* class_loader, uint32_t class_def_idx, const DexFile::CodeItem* code_item,
-      Method* method, uint32_t method_access_flags);
-  static void VerifyMethodAndDump(Method* method);
+      Method* method, uint32_t method_access_flags)
+          SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void VerifyMethodAndDump(Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Run verification on the method. Returns true if verification completes and false if the input
   // has an irrecoverable corruption.
-  bool Verify();
+  bool Verify() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void FindLocksAtDexPc();
+  void FindLocksAtDexPc() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Compute the width of the instruction at each address in the instruction stream, and store it in
@@ -267,7 +276,7 @@
    * Returns "false" if something in the exception table looks fishy, but we're expecting the
    * exception table to be somewhat sane.
    */
-  bool ScanTryCatchBlocks();
+  bool ScanTryCatchBlocks() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Perform static verification on all instructions in a method.
@@ -373,11 +382,11 @@
                        bool* selfOkay);
 
   /* Perform detailed code-flow analysis on a single method. */
-  bool VerifyCodeFlow();
+  bool VerifyCodeFlow() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Set the register types for the first instruction in the method based on the method signature.
   // This has the side-effect of validating the signature.
-  bool SetTypesFromSignature();
+  bool SetTypesFromSignature() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Perform code flow on a method.
@@ -425,7 +434,7 @@
    * reordering by specifying that you can't execute the new-instance instruction if a register
    * contains an uninitialized instance created by that same instruction.
    */
-  bool CodeFlowVerifyMethod();
+  bool CodeFlowVerifyMethod() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Perform verification for a single instruction.
@@ -436,54 +445,62 @@
    * point needs to be (re-)evaluated. Register changes are merged into "reg_types_" at the target
    * addresses. Does not set or clear any other flags in "insn_flags_".
    */
-  bool CodeFlowVerifyInstruction(uint32_t* start_guess);
+  bool CodeFlowVerifyInstruction(uint32_t* start_guess)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Perform verification of a new array instruction
   void VerifyNewArray(const DecodedInstruction& dec_insn, bool is_filled,
-                      bool is_range);
+                      bool is_range)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Perform verification of an aget instruction. The destination register's type will be set to
   // be that of component type of the array unless the array type is unknown, in which case a
   // bottom type inferred from the type of instruction is used. is_primitive is false for an
   // aget-object.
   void VerifyAGet(const DecodedInstruction& insn, const RegType& insn_type,
-                  bool is_primitive);
+                  bool is_primitive) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Perform verification of an aput instruction.
   void VerifyAPut(const DecodedInstruction& insn, const RegType& insn_type,
-                  bool is_primitive);
+                  bool is_primitive) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Lookup instance field and fail for resolution violations
-  Field* GetInstanceField(const RegType& obj_type, int field_idx);
+  Field* GetInstanceField(const RegType& obj_type, int field_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Lookup static field and fail for resolution violations
-  Field* GetStaticField(int field_idx);
+  Field* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Perform verification of an iget or sget instruction.
   void VerifyISGet(const DecodedInstruction& insn, const RegType& insn_type,
-                   bool is_primitive, bool is_static);
+                   bool is_primitive, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Perform verification of an iput or sput instruction.
   void VerifyISPut(const DecodedInstruction& insn, const RegType& insn_type,
-                   bool is_primitive, bool is_static);
+                   bool is_primitive, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolves a class based on an index and performs access checks to ensure the referrer can
   // access the resolved class.
-  const RegType& ResolveClassAndCheckAccess(uint32_t class_idx);
+  const RegType& ResolveClassAndCheckAccess(uint32_t class_idx)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * For the "move-exception" instruction at "work_insn_idx_", which must be at an exception handler
    * address, determine the Join of all exceptions that can land here. Fails if no matching
    * exception handler can be found or if the Join of exception types fails.
    */
-  const RegType& GetCaughtExceptionType();
+  const RegType& GetCaughtExceptionType()
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Resolves a method based on an index and performs access checks to ensure
    * the referrer can access the resolved method.
    * Does not throw exceptions.
    */
-  Method* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type);
+  Method* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify the arguments to a method. We're executing in "method", making
@@ -508,7 +525,8 @@
    * set appropriately).
    */
   Method* VerifyInvocationArgs(const DecodedInstruction& dec_insn,
-                               MethodType method_type, bool is_range, bool is_super);
+                               MethodType method_type, bool is_range, bool is_super)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify that the target instruction is not "move-exception". It's important that the only way
@@ -528,7 +546,8 @@
   * next_insn, and set the changed flag on the target address if any of the registers were changed.
   * Returns "false" if an error is encountered.
   */
-  bool UpdateRegisters(uint32_t next_insn, const RegisterLine* merge_line);
+  bool UpdateRegisters(uint32_t next_insn, const RegisterLine* merge_line)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Is the method being verified a constructor?
   bool IsConstructor() const {
@@ -541,10 +560,10 @@
   }
 
   // Return the register type for the method.
-  const RegType& GetMethodReturnType();
+  const RegType& GetMethodReturnType() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get a type representing the declaring class of the method.
-  const RegType& GetDeclaringClass();
+  const RegType& GetDeclaringClass() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 #if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
   /*
@@ -572,25 +591,27 @@
 
   // All the GC maps that the verifier has created
   typedef SafeMap<const Compiler::MethodReference, const std::vector<uint8_t>*> GcMapTable;
-  static Mutex* gc_maps_lock_;
-  static GcMapTable* gc_maps_;
-  static void SetGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map);
+  static Mutex* gc_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+  static GcMapTable* gc_maps_ GUARDED_BY(gc_maps_lock_);
+  static void SetGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map)
+      LOCKS_EXCLUDED(gc_maps_lock_);
 
   typedef std::set<Compiler::ClassReference> RejectedClassesTable;
-  static Mutex* rejected_classes_lock_;
+  static Mutex* rejected_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   static RejectedClassesTable* rejected_classes_;
 
 #if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
   // All the inferred register category maps that the verifier has created.
   typedef SafeMap<const Compiler::MethodReference,
                   const InferredRegCategoryMap*> InferredRegCategoryMapTable;
-  static Mutex* inferred_reg_category_maps_lock_;
+  static Mutex* inferred_reg_category_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   static InferredRegCategoryMapTable* inferred_reg_category_maps_;
   static void SetInferredRegCategoryMap(Compiler::MethodReference ref,
                                         const InferredRegCategoryMap& m);
 #endif
 
-  static void AddRejectedClass(Compiler::ClassReference ref);
+  static void AddRejectedClass(Compiler::ClassReference ref)
+      LOCKS_EXCLUDED(rejected_classes_lock_);
 
   RegTypeCache reg_types_;
 
@@ -607,11 +628,14 @@
   UniquePtr<RegisterLine> saved_line_;
 
   uint32_t method_idx_;  // The method we're working on.
-  Method* foo_method_;  // Its object representation if known.
+  // Its object representation if known.
+  Method* foo_method_ GUARDED_BY(GlobalSynchronization::mutator_lock_);
   uint32_t method_access_flags_;  // Method's access flags.
   const DexFile* dex_file_;  // The dex file containing the method.
-  DexCache* dex_cache_;  // The dex_cache for the declaring class of the method.
-  ClassLoader* class_loader_;  // The class loader for the declaring class of the method.
+  // The dex_cache for the declaring class of the method.
+  DexCache* dex_cache_ GUARDED_BY(GlobalSynchronization::mutator_lock_);
+  // The class loader for the declaring class of the method.
+  ClassLoader* class_loader_ GUARDED_BY(GlobalSynchronization::mutator_lock_);
   uint32_t class_def_idx_;  // The class def index of the declaring class of the method.
   const DexFile::CodeItem* code_item_;  // The code item containing the code for the method.
   UniquePtr<InsnFlags[]> insn_flags_;  // Instruction widths and flags, one entry per code unit.
diff --git a/src/verifier/method_verifier_test.cc b/src/verifier/method_verifier_test.cc
index 5c23e9f..e52feb3 100644
--- a/src/verifier/method_verifier_test.cc
+++ b/src/verifier/method_verifier_test.cc
@@ -27,7 +27,8 @@
 
 class MethodVerifierTest : public CommonTest {
  protected:
-  void VerifyClass(const std::string& descriptor) {
+  void VerifyClass(const std::string& descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ASSERT_TRUE(descriptor != NULL);
     Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
 
@@ -36,7 +37,8 @@
     ASSERT_TRUE(MethodVerifier::VerifyClass(klass, error_msg) == MethodVerifier::kNoFailure) << error_msg;
   }
 
-  void VerifyDexFile(const DexFile* dex) {
+  void VerifyDexFile(const DexFile* dex)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     ASSERT_TRUE(dex != NULL);
 
     // Verify all the classes defined in this file
@@ -49,12 +51,14 @@
 };
 
 TEST_F(MethodVerifierTest, LibCore) {
+  ScopedObjectAccess soa(Thread::Current());
   VerifyDexFile(java_lang_dex_file_);
 }
 
 TEST_F(MethodVerifierTest, IntMath) {
-  SirtRef<ClassLoader> class_loader(LoadDex("IntMath"));
-  Class* klass = class_linker_->FindClass("LIntMath;", class_loader.get());
+  ScopedObjectAccess soa(Thread::Current());
+  jobject class_loader = LoadDex("IntMath");
+  Class* klass = class_linker_->FindClass("LIntMath;", soa.Decode<ClassLoader*>(class_loader));
   std::string error_msg;
   ASSERT_TRUE(MethodVerifier::VerifyClass(klass, error_msg) == MethodVerifier::kNoFailure) << error_msg;
 }
diff --git a/src/verifier/reg_type.cc b/src/verifier/reg_type.cc
index 8d1df22..281d96e 100644
--- a/src/verifier/reg_type.cc
+++ b/src/verifier/reg_type.cc
@@ -384,7 +384,8 @@
   }
 }
 
-std::ostream& operator<<(std::ostream& os, const RegType& rhs) {
+std::ostream& operator<<(std::ostream& os, const RegType& rhs)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   os << rhs.Dump();
   return os;
 }
diff --git a/src/verifier/reg_type.h b/src/verifier/reg_type.h
index 7e8fca1..a0e2ff8 100644
--- a/src/verifier/reg_type.h
+++ b/src/verifier/reg_type.h
@@ -117,7 +117,8 @@
   }
 
   // The high half that corresponds to this low half
-  const RegType& HighHalf(RegTypeCache* cache) const;
+  const RegType& HighHalf(RegTypeCache* cache) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsConstant() const { return type_ == kRegTypeConst; }
   bool IsLongConstant() const { return type_ == kRegTypeConstLo; }
@@ -208,7 +209,7 @@
     return IsReference() && GetClass()->IsObjectClass();
   }
 
-  bool IsArrayTypes() const {
+  bool IsArrayTypes() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
       return GetDescriptor()->CharAt(0) == '[';
     } else if (IsReference()) {
@@ -218,7 +219,7 @@
     }
   }
 
-  bool IsObjectArrayTypes() const {
+  bool IsObjectArrayTypes() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
       // Primitive arrays will always resolve
       DCHECK(GetDescriptor()->CharAt(1) == 'L' || GetDescriptor()->CharAt(1) == '[');
@@ -293,22 +294,28 @@
     return static_cast<uint16_t>(allocation_pc_or_constant_or_merged_types_ & 0xFFFF);
   }
 
-  const RegType& GetSuperClass(RegTypeCache* cache) const;
+  const RegType& GetSuperClass(RegTypeCache* cache) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  std::string Dump(const RegTypeCache* reg_types = NULL) const;
+  std::string Dump(const RegTypeCache* reg_types = NULL) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Can this type access other?
-  bool CanAccess(const RegType& other) const;
+  bool CanAccess(const RegType& other) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   // Can this type access a member with the given properties?
-  bool CanAccessMember(Class* klass, uint32_t access_flags) const;
+  bool CanAccessMember(Class* klass, uint32_t access_flags) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Can this type be assigned by src?
-  bool IsAssignableFrom(const RegType& src) const;
+  bool IsAssignableFrom(const RegType& src) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool Equals(const RegType& other) const { return GetId() == other.GetId(); }
 
   // Compute the merge of this register from one edge (path) with incoming_type from another.
-  const RegType& Merge(const RegType& incoming_type, RegTypeCache* reg_types) const;
+  const RegType& Merge(const RegType& incoming_type, RegTypeCache* reg_types) const
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * A basic Join operation on classes. For a pair of types S and T the Join, written S v T = J, is
@@ -326,7 +333,8 @@
    *
    * [1] Java bytecode verification: algorithms and formalizations, Xavier Leroy
    */
-  static Class* ClassJoin(Class* s, Class* t);
+  static Class* ClassJoin(Class* s, Class* t)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   friend class RegTypeCache;
diff --git a/src/verifier/reg_type_cache.h b/src/verifier/reg_type_cache.h
index 4ba667b..1287388 100644
--- a/src/verifier/reg_type_cache.h
+++ b/src/verifier/reg_type_cache.h
@@ -40,32 +40,68 @@
     return *result;
   }
 
-  const RegType& From(RegType::Type type, ClassLoader* loader, const char* descriptor);
-  const RegType& FromClass(Class* klass);
+  const RegType& From(RegType::Type type, ClassLoader* loader, const char* descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  const RegType& FromClass(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   const RegType& FromCat1Const(int32_t value);
-  const RegType& FromDescriptor(ClassLoader* loader, const char* descriptor);
-  const RegType& FromType(RegType::Type);
+  const RegType& FromDescriptor(ClassLoader* loader, const char* descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  const RegType& FromType(RegType::Type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   const RegType& FromUnresolvedMerge(const RegType& left, const RegType& right);
   const RegType& FromUnresolvedSuperClass(const RegType& child);
 
-  const RegType& Boolean() { return FromType(RegType::kRegTypeBoolean); }
-  const RegType& Byte()    { return FromType(RegType::kRegTypeByte); }
-  const RegType& Char()    { return FromType(RegType::kRegTypeChar); }
-  const RegType& Short()   { return FromType(RegType::kRegTypeShort); }
-  const RegType& Integer() { return FromType(RegType::kRegTypeInteger); }
-  const RegType& Float()   { return FromType(RegType::kRegTypeFloat); }
-  const RegType& Long()    { return FromType(RegType::kRegTypeLongLo); }
-  const RegType& Double()  { return FromType(RegType::kRegTypeDoubleLo); }
+  const RegType& Boolean() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeBoolean);
+  }
+  const RegType& Byte() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeByte);
+  }
+  const RegType& Char() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeChar);
+  }
+  const RegType& Short() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeShort);
+  }
+  const RegType& Integer() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeInteger);
+  }
+  const RegType& Float() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeFloat);
+  }
+  const RegType& Long() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeLongLo);
+  }
+  const RegType& Double() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeDoubleLo);
+  }
 
-  const RegType& JavaLangClass()  { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Class;"); }
-  const RegType& JavaLangObject() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Object;"); }
-  const RegType& JavaLangString() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/String;"); }
-  const RegType& JavaLangThrowable() { return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Throwable;"); }
+  const RegType& JavaLangClass() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Class;");
+  }
+  const RegType& JavaLangObject() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Object;");
+  }
+  const RegType& JavaLangString() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return From(RegType::kRegTypeReference, NULL, "Ljava/lang/String;");
+  }
+  const RegType& JavaLangThrowable() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return From(RegType::kRegTypeReference, NULL, "Ljava/lang/Throwable;");
+  }
 
-  const RegType& Undefined() { return FromType(RegType::kRegTypeUndefined); }
-  const RegType& Conflict()  { return FromType(RegType::kRegTypeConflict); }
-  const RegType& ConstLo()   { return FromType(RegType::kRegTypeConstLo); }
-  const RegType& Zero()      { return FromCat1Const(0); }
+  const RegType& Undefined() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeUndefined);
+  }
+  const RegType& Conflict() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeConflict);
+  }
+  const RegType& ConstLo() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromType(RegType::kRegTypeConstLo);
+  }
+  const RegType& Zero() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
+    return FromCat1Const(0);
+  }
 
   const RegType& Uninitialized(const RegType& type, uint32_t allocation_pc);
   // Create an uninitialized 'this' argument for the given type.
@@ -79,7 +115,8 @@
   const RegType& ShortConstant() { return FromCat1Const(std::numeric_limits<jshort>::min()); }
   const RegType& IntConstant() { return FromCat1Const(std::numeric_limits<jint>::max()); }
 
-  const RegType& GetComponentType(const RegType& array, ClassLoader* loader);
+  const RegType& GetComponentType(const RegType& array, ClassLoader* loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
  private:
   // The allocated entries
diff --git a/src/verifier/reg_type_test.cc b/src/verifier/reg_type_test.cc
index 18c1655..6bdf886 100644
--- a/src/verifier/reg_type_test.cc
+++ b/src/verifier/reg_type_test.cc
@@ -26,6 +26,7 @@
 class RegTypeTest : public CommonTest {};
 
 TEST_F(RegTypeTest, Primitives) {
+  ScopedObjectAccess soa(Thread::Current());
   RegTypeCache cache;
 
   const RegType& bool_reg_type = cache.Boolean();
diff --git a/src/verifier/register_line.cc b/src/verifier/register_line.cc
index 1d4366f..ec7891e 100644
--- a/src/verifier/register_line.cc
+++ b/src/verifier/register_line.cc
@@ -367,7 +367,8 @@
   }
 }
 
-std::ostream& operator<<(std::ostream& os, const RegisterLine& rhs) {
+std::ostream& operator<<(std::ostream& os, const RegisterLine& rhs)
+    SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
   os << rhs.Dump();
   return os;
 }
diff --git a/src/verifier/register_line.h b/src/verifier/register_line.h
index 9664a5b..1d131ad 100644
--- a/src/verifier/register_line.h
+++ b/src/verifier/register_line.h
@@ -61,19 +61,23 @@
   }
 
   // Implement category-1 "move" instructions. Copy a 32-bit value from "vsrc" to "vdst".
-  void CopyRegister1(uint32_t vdst, uint32_t vsrc, TypeCategory cat);
+  void CopyRegister1(uint32_t vdst, uint32_t vsrc, TypeCategory cat)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Implement category-2 "move" instructions. Copy a 64-bit value from "vsrc" to "vdst". This
   // copies both halves of the register.
-  void CopyRegister2(uint32_t vdst, uint32_t vsrc);
+  void CopyRegister2(uint32_t vdst, uint32_t vsrc)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Implement "move-result". Copy the category-1 value from the result register to another
   // register, and reset the result register.
-  void CopyResultRegister1(uint32_t vdst, bool is_reference);
+  void CopyResultRegister1(uint32_t vdst, bool is_reference)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Implement "move-result-wide". Copy the category-2 value from the result register to another
   // register, and reset the result register.
-  void CopyResultRegister2(uint32_t vdst);
+  void CopyResultRegister2(uint32_t vdst)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Set the invisible result register to unknown
   void SetResultTypeToUnknown();
@@ -81,15 +85,18 @@
   // Set the type of register N, verifying that the register is valid.  If "newType" is the "Lo"
   // part of a 64-bit value, register N+1 will be set to "newType+1".
   // The register index was validated during the static pass, so we don't need to check it here.
-  bool SetRegisterType(uint32_t vdst, const RegType& new_type);
+  bool SetRegisterType(uint32_t vdst, const RegType& new_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /* Set the type of the "result" register. */
-  void SetResultRegisterType(const RegType& new_type);
+  void SetResultRegisterType(const RegType& new_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get the type of register vsrc.
   const RegType& GetRegisterType(uint32_t vsrc) const;
 
-  bool VerifyRegisterType(uint32_t vsrc, const RegType& check_type);
+  bool VerifyRegisterType(uint32_t vsrc, const RegType& check_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void CopyFromLine(const RegisterLine* src) {
     DCHECK_EQ(num_regs_, src->num_regs_);
@@ -98,7 +105,7 @@
     reg_to_lock_depths_ = src->reg_to_lock_depths_;
   }
 
-  std::string Dump() const;
+  std::string Dump() const SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void FillWithGarbage() {
     memset(line_.get(), 0xf1, num_regs_ * sizeof(uint16_t));
@@ -114,7 +121,8 @@
    * to prevent them from being used (otherwise, MarkRefsAsInitialized would mark the old ones and
    * the new ones at the same time).
    */
-  void MarkUninitRefsAsInvalid(const RegType& uninit_type);
+  void MarkUninitRefsAsInvalid(const RegType& uninit_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Update all registers holding "uninit_type" to instead hold the corresponding initialized
@@ -152,14 +160,16 @@
    * The argument count is in vA, and the first argument is in vC, for both "simple" and "range"
    * versions. We just need to make sure vA is >= 1 and then return vC.
    */
-  const RegType& GetInvocationThis(const DecodedInstruction& dec_insn);
+  const RegType& GetInvocationThis(const DecodedInstruction& dec_insn)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify types for a simple two-register instruction (e.g. "neg-int").
    * "dst_type" is stored into vA, and "src_type" is verified against vB.
    */
   void CheckUnaryOp(const DecodedInstruction& dec_insn,
-                    const RegType& dst_type, const RegType& src_type);
+                    const RegType& dst_type, const RegType& src_type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify types for a simple three-register instruction (e.g. "add-int").
@@ -168,7 +178,8 @@
    */
   void CheckBinaryOp(const DecodedInstruction& dec_insn,
                      const RegType& dst_type, const RegType& src_type1, const RegType& src_type2,
-                     bool check_boolean_op);
+                     bool check_boolean_op)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify types for a binary "2addr" operation. "src_type1"/"src_type2"
@@ -177,7 +188,8 @@
   void CheckBinaryOp2addr(const DecodedInstruction& dec_insn,
                           const RegType& dst_type,
                           const RegType& src_type1, const RegType& src_type2,
-                          bool check_boolean_op);
+                          bool check_boolean_op)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   /*
    * Verify types for A two-register instruction with a literal constant (e.g. "add-int/lit8").
@@ -186,7 +198,8 @@
    * If "check_boolean_op" is set, we use the constant value in vC.
    */
   void CheckLiteralOp(const DecodedInstruction& dec_insn,
-                      const RegType& dst_type, const RegType& src_type, bool check_boolean_op);
+                      const RegType& dst_type, const RegType& src_type, bool check_boolean_op)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Verify/push monitor onto the monitor stack, locking the value in reg_idx at location insn_idx.
   void PushMonitor(uint32_t reg_idx, int32_t insn_idx);
@@ -203,7 +216,8 @@
   // is empty, failing and returning false if not.
   bool VerifyMonitorStackEmpty();
 
-  bool MergeRegisters(const RegisterLine* incoming_line);
+  bool MergeRegisters(const RegisterLine* incoming_line)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   size_t GetMaxNonZeroReferenceReg(size_t max_ref_reg) {
     size_t i = static_cast<int>(max_ref_reg) < 0 ? 0 : max_ref_reg;
diff --git a/src/well_known_classes.cc b/src/well_known_classes.cc
index a0397ff..cae7369 100644
--- a/src/well_known_classes.cc
+++ b/src/well_known_classes.cc
@@ -25,6 +25,7 @@
 namespace art {
 
 jclass WellKnownClasses::com_android_dex_Dex;
+jclass WellKnownClasses::dalvik_system_PathClassLoader;
 jclass WellKnownClasses::java_lang_ClassLoader;
 jclass WellKnownClasses::java_lang_ClassNotFoundException;
 jclass WellKnownClasses::java_lang_Daemons;
@@ -43,14 +44,22 @@
 jclass WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer;
 
 jmethodID WellKnownClasses::com_android_dex_Dex_create;
-jmethodID WellKnownClasses::java_lang_ClassNotFoundException_init;
+jmethodID WellKnownClasses::java_lang_Boolean_valueOf;
+jmethodID WellKnownClasses::java_lang_Byte_valueOf;
+jmethodID WellKnownClasses::java_lang_Character_valueOf;
 jmethodID WellKnownClasses::java_lang_ClassLoader_loadClass;
+jmethodID WellKnownClasses::java_lang_ClassNotFoundException_init;
 jmethodID WellKnownClasses::java_lang_Daemons_requestGC;
 jmethodID WellKnownClasses::java_lang_Daemons_requestHeapTrim;
 jmethodID WellKnownClasses::java_lang_Daemons_start;
+jmethodID WellKnownClasses::java_lang_Double_valueOf;
+jmethodID WellKnownClasses::java_lang_Float_valueOf;
+jmethodID WellKnownClasses::java_lang_Integer_valueOf;
+jmethodID WellKnownClasses::java_lang_Long_valueOf;
 jmethodID WellKnownClasses::java_lang_ref_FinalizerReference_add;
 jmethodID WellKnownClasses::java_lang_ref_ReferenceQueue_add;
 jmethodID WellKnownClasses::java_lang_reflect_InvocationHandler_invoke;
+jmethodID WellKnownClasses::java_lang_Short_valueOf;
 jmethodID WellKnownClasses::java_lang_Thread_init;
 jmethodID WellKnownClasses::java_lang_Thread_run;
 jmethodID WellKnownClasses::java_lang_Thread$UncaughtExceptionHandler_uncaughtException;
@@ -102,8 +111,15 @@
   return mid;
 }
 
-void WellKnownClasses::Init(JNIEnv* env) {
+static jmethodID CachePrimitiveBoxingMethod(JNIEnv* env, char prim_name, const char* boxed_name) {
+  ScopedLocalRef<jclass> boxed_class(env, env->FindClass(boxed_name));
+  return CacheMethod(env, boxed_class.get(), true, "valueOf",
+                     StringPrintf("(%c)L%s;", prim_name, boxed_name).c_str());
+}
+
+void WellKnownClasses::InitClasses(JNIEnv* env) {
   com_android_dex_Dex = CacheClass(env, "com/android/dex/Dex");
+  dalvik_system_PathClassLoader = CacheClass(env, "dalvik/system/PathClassLoader");
   java_lang_ClassLoader = CacheClass(env, "java/lang/ClassLoader");
   java_lang_ClassNotFoundException = CacheClass(env, "java/lang/ClassNotFoundException");
   java_lang_Daemons = CacheClass(env, "java/lang/Daemons");
@@ -120,6 +136,10 @@
   java_nio_ReadWriteDirectByteBuffer = CacheClass(env, "java/nio/ReadWriteDirectByteBuffer");
   org_apache_harmony_dalvik_ddmc_Chunk = CacheClass(env, "org/apache/harmony/dalvik/ddmc/Chunk");
   org_apache_harmony_dalvik_ddmc_DdmServer = CacheClass(env, "org/apache/harmony/dalvik/ddmc/DdmServer");
+}
+
+void WellKnownClasses::Init(JNIEnv* env) {
+  InitClasses(env);
 
   com_android_dex_Dex_create = CacheMethod(env, com_android_dex_Dex, true, "create", "(Ljava/nio/ByteBuffer;)Lcom/android/dex/Dex;");
   java_lang_ClassNotFoundException_init = CacheMethod(env, java_lang_ClassNotFoundException, false, "<init>", "(Ljava/lang/String;Ljava/lang/Throwable;)V");
@@ -161,6 +181,15 @@
   org_apache_harmony_dalvik_ddmc_Chunk_length = CacheField(env, org_apache_harmony_dalvik_ddmc_Chunk, false, "length", "I");
   org_apache_harmony_dalvik_ddmc_Chunk_offset = CacheField(env, org_apache_harmony_dalvik_ddmc_Chunk, false, "offset", "I");
   org_apache_harmony_dalvik_ddmc_Chunk_type = CacheField(env, org_apache_harmony_dalvik_ddmc_Chunk, false, "type", "I");
+
+  java_lang_Boolean_valueOf = CachePrimitiveBoxingMethod(env, 'Z', "java/lang/Boolean");
+  java_lang_Byte_valueOf = CachePrimitiveBoxingMethod(env, 'B', "java/lang/Byte");
+  java_lang_Character_valueOf = CachePrimitiveBoxingMethod(env, 'C', "java/lang/Character");
+  java_lang_Double_valueOf = CachePrimitiveBoxingMethod(env, 'D', "java/lang/Double");
+  java_lang_Float_valueOf = CachePrimitiveBoxingMethod(env, 'F', "java/lang/Float");
+  java_lang_Integer_valueOf = CachePrimitiveBoxingMethod(env, 'I', "java/lang/Integer");
+  java_lang_Long_valueOf = CachePrimitiveBoxingMethod(env, 'J', "java/lang/Long");
+  java_lang_Short_valueOf = CachePrimitiveBoxingMethod(env, 'S', "java/lang/Short");
 }
 
 Class* WellKnownClasses::ToClass(jclass global_jclass) {
diff --git a/src/well_known_classes.h b/src/well_known_classes.h
index d2c4959..15961e2 100644
--- a/src/well_known_classes.h
+++ b/src/well_known_classes.h
@@ -18,6 +18,7 @@
 #define ART_SRC_WELL_KNOWN_CLASSES_H_
 
 #include "jni.h"
+#include "mutex.h"
 
 namespace art {
 
@@ -28,11 +29,14 @@
 // we keep them separate).
 
 struct WellKnownClasses {
+  static void InitClasses(JNIEnv* env);
   static void Init(JNIEnv* env);
 
-  static Class* ToClass(jclass global_jclass);
+  static Class* ToClass(jclass global_jclass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   static jclass com_android_dex_Dex;
+  static jclass dalvik_system_PathClassLoader;
   static jclass java_lang_ClassLoader;
   static jclass java_lang_ClassNotFoundException;
   static jclass java_lang_Daemons;
@@ -51,14 +55,22 @@
   static jclass org_apache_harmony_dalvik_ddmc_DdmServer;
 
   static jmethodID com_android_dex_Dex_create;
+  static jmethodID java_lang_Boolean_valueOf;
+  static jmethodID java_lang_Byte_valueOf;
+  static jmethodID java_lang_Character_valueOf;
   static jmethodID java_lang_ClassLoader_loadClass;
   static jmethodID java_lang_ClassNotFoundException_init;
   static jmethodID java_lang_Daemons_requestGC;
   static jmethodID java_lang_Daemons_requestHeapTrim;
   static jmethodID java_lang_Daemons_start;
+  static jmethodID java_lang_Double_valueOf;
+  static jmethodID java_lang_Float_valueOf;
+  static jmethodID java_lang_Integer_valueOf;
+  static jmethodID java_lang_Long_valueOf;
   static jmethodID java_lang_ref_FinalizerReference_add;
   static jmethodID java_lang_ref_ReferenceQueue_add;
   static jmethodID java_lang_reflect_InvocationHandler_invoke;
+  static jmethodID java_lang_Short_valueOf;
   static jmethodID java_lang_Thread_init;
   static jmethodID java_lang_Thread_run;
   static jmethodID java_lang_Thread$UncaughtExceptionHandler_uncaughtException;
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index ddda260..0aefa97 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -20,6 +20,7 @@
 #include "class_linker.h"
 #include "object.h"
 #include "object_utils.h"
+#include "scoped_thread_state_change.h"
 #include "thread.h"
 #include "jni.h"
 #include "verifier/gc_map.h"
@@ -42,11 +43,12 @@
 
 struct ReferenceMap2Visitor : public StackVisitor {
   explicit ReferenceMap2Visitor(const ManagedStack* stack,
-                                const std::vector<TraceStackFrame>* trace_stack) :
-    StackVisitor(stack, trace_stack, NULL) {
+                                const std::vector<TraceStackFrame>* trace_stack)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      : StackVisitor(stack, trace_stack, NULL) {
   }
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* m = GetMethod();
     if (!m || m->IsNative() || m->IsRuntimeMethod() || IsShadowFrame()) {
       return true;
@@ -62,7 +64,7 @@
 
     // Enable this to dump reference map to LOG(INFO)
     if (false) {
-      ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+      ScopedObjectAccess ts(Thread::Current());
       art::verifier::MethodVerifier::VerifyMethodAndDump(m);
     }
     const uint8_t* ref_bitmap = NULL;
@@ -281,6 +283,7 @@
 
 extern "C" JNIEXPORT jint JNICALL Java_ReferenceMap_refmap(JNIEnv*, jobject, jint count) {
   // Visitor
+  ScopedObjectAccess ts(Thread::Current());
   ReferenceMap2Visitor mapper(Thread::Current()->GetManagedStack(),
                               Thread::Current()->GetTraceStack());
   mapper.WalkStack();
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index 9382b8f..41e8d58 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -21,6 +21,7 @@
 #include "object.h"
 #include "object_utils.h"
 #include "jni.h"
+#include "scoped_thread_state_change.h"
 #include "verifier/gc_map.h"
 
 namespace art {
@@ -41,10 +42,11 @@
 struct TestReferenceMapVisitor : public StackVisitor {
   explicit TestReferenceMapVisitor(const ManagedStack* stack,
                                    const std::vector<TraceStackFrame>* trace_stack)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
       : StackVisitor(stack, trace_stack, NULL) {
   }
 
-  bool VisitFrame() {
+  bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* m = GetMethod();
     CHECK(m != NULL);
     LOG(INFO) << "At " << PrettyMethod(m, false);
@@ -100,6 +102,7 @@
 };
 
 extern "C" JNIEXPORT jint JNICALL Java_StackWalk_refmap(JNIEnv*, jobject, jint count) {
+  ScopedObjectAccess ts(Thread::Current());
   CHECK_EQ(count, 0);
   gJava_StackWalk_refmap_calls++;
 
@@ -112,6 +115,7 @@
 }
 
 extern "C" JNIEXPORT jint JNICALL Java_StackWalk2_refmap2(JNIEnv*, jobject, jint count) {
+  ScopedObjectAccess ts(Thread::Current());
   gJava_StackWalk_refmap_calls++;
 
   // Visitor