diff --git a/src/atomic.cc b/src/atomic.cc
index 2638b21..008aa87 100644
--- a/src/atomic.cc
+++ b/src/atomic.cc
@@ -22,6 +22,7 @@
 #include "mutex.h"
 #include "stl_util.h"
 #include "stringprintf.h"
+#include "thread.h"
 
 #if defined(__APPLE__)
 #include <libkern/OSAtomic.h>
@@ -172,7 +173,7 @@
 }
 
 int64_t QuasiAtomic::Swap64(int64_t value, volatile int64_t* addr) {
-  MutexLock mu(GetSwapLock(addr));
+  MutexLock mu(Thread::Current(), GetSwapLock(addr));
   int64_t old_value = *addr;
   *addr = value;
   return old_value;
@@ -184,7 +185,7 @@
 }
 
 int QuasiAtomic::Cas64(int64_t old_value, int64_t new_value, volatile int64_t* addr) {
-  MutexLock mu(GetSwapLock(addr));
+  MutexLock mu(Thread::Current(), GetSwapLock(addr));
   if (*addr == old_value) {
     *addr  = new_value;
     return 0;
@@ -193,7 +194,7 @@
 }
 
 int64_t QuasiAtomic::Read64(volatile const int64_t* addr) {
-  MutexLock mu(GetSwapLock(addr));
+  MutexLock mu(Thread::Current(), GetSwapLock(addr));
   return *addr;
 }
 
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 448ad6a..9ce641f 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -235,47 +235,48 @@
   // java_lang_Class comes first, it's needed for AllocClass
   Thread* self = Thread::Current();
   Heap* heap = Runtime::Current()->GetHeap();
-  SirtRef<Class> java_lang_Class(self, down_cast<Class*>(heap->AllocObject(NULL, sizeof(ClassClass))));
+  SirtRef<Class>
+      java_lang_Class(self, down_cast<Class*>(heap->AllocObject(self, NULL, sizeof(ClassClass))));
   CHECK(java_lang_Class.get() != NULL);
   java_lang_Class->SetClass(java_lang_Class.get());
   java_lang_Class->SetClassSize(sizeof(ClassClass));
   // AllocClass(Class*) can now be used
 
   // Class[] is used for reflection support.
-  SirtRef<Class> class_array_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   class_array_class->SetComponentType(java_lang_Class.get());
 
   // java_lang_Object comes next so that object_array_class can be created.
-  SirtRef<Class> java_lang_Object(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   CHECK(java_lang_Object.get() != NULL);
   // backfill Object as the super class of Class.
   java_lang_Class->SetSuperClass(java_lang_Object.get());
   java_lang_Object->SetStatus(Class::kStatusLoaded);
 
   // Object[] next to hold class roots.
-  SirtRef<Class> object_array_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   object_array_class->SetComponentType(java_lang_Object.get());
 
   // Object[][] needed for iftables.
-  SirtRef<Class> object_array_array_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> object_array_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   object_array_array_class->SetComponentType(object_array_class.get());
 
   // Setup the char class to be used for char[].
-  SirtRef<Class> char_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
 
   // Setup the char[] class to be used for String.
-  SirtRef<Class> char_array_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   char_array_class->SetComponentType(char_class.get());
   CharArray::SetArrayClass(char_array_class.get());
 
   // Setup String.
-  SirtRef<Class> java_lang_String(self, AllocClass(java_lang_Class.get(), sizeof(StringClass)));
+  SirtRef<Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(StringClass)));
   String::SetClass(java_lang_String.get());
   java_lang_String->SetObjectSize(sizeof(String));
   java_lang_String->SetStatus(Class::kStatusResolved);
 
   // Create storage for root classes, save away our work so far (requires descriptors).
-  class_roots_ = ObjectArray<Class>::Alloc(object_array_class.get(), kClassRootsMax);
+  class_roots_ = ObjectArray<Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
   CHECK(class_roots_ != NULL);
   SetClassRoot(kJavaLangClass, java_lang_Class.get());
   SetClassRoot(kJavaLangObject, java_lang_Object.get());
@@ -286,20 +287,20 @@
   SetClassRoot(kJavaLangString, java_lang_String.get());
 
   // Setup the primitive type classes.
-  SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(Primitive::kPrimBoolean));
-  SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(Primitive::kPrimByte));
-  SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(Primitive::kPrimShort));
-  SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(Primitive::kPrimInt));
-  SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(Primitive::kPrimLong));
-  SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(Primitive::kPrimFloat));
-  SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(Primitive::kPrimDouble));
-  SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(Primitive::kPrimVoid));
+  SetClassRoot(kPrimitiveBoolean, CreatePrimitiveClass(self, Primitive::kPrimBoolean));
+  SetClassRoot(kPrimitiveByte, CreatePrimitiveClass(self, Primitive::kPrimByte));
+  SetClassRoot(kPrimitiveShort, CreatePrimitiveClass(self, Primitive::kPrimShort));
+  SetClassRoot(kPrimitiveInt, CreatePrimitiveClass(self, Primitive::kPrimInt));
+  SetClassRoot(kPrimitiveLong, CreatePrimitiveClass(self, Primitive::kPrimLong));
+  SetClassRoot(kPrimitiveFloat, CreatePrimitiveClass(self, Primitive::kPrimFloat));
+  SetClassRoot(kPrimitiveDouble, CreatePrimitiveClass(self, Primitive::kPrimDouble));
+  SetClassRoot(kPrimitiveVoid, CreatePrimitiveClass(self, Primitive::kPrimVoid));
 
   // Create array interface entries to populate once we can load system classes.
-  array_iftable_ = AllocIfTable(2);
+  array_iftable_ = AllocIfTable(self, 2);
 
   // Create int array type for AllocDexCache (done in AppendToBootClassPath).
-  SirtRef<Class> int_array_class(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
   IntArray::SetArrayClass(int_array_class.get());
   SetClassRoot(kIntArrayClass, int_array_class.get());
@@ -307,34 +308,37 @@
   // now that these are registered, we can use AllocClass() and AllocObjectArray
 
   // Setup DexCache. This can not be done later since AppendToBootClassPath calls AllocDexCache.
-  SirtRef<Class> java_lang_DexCache(self, AllocClass(java_lang_Class.get(), sizeof(DexCacheClass)));
+  SirtRef<Class>
+      java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(DexCacheClass)));
   SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
   java_lang_DexCache->SetObjectSize(sizeof(DexCacheClass));
   java_lang_DexCache->SetStatus(Class::kStatusResolved);
 
   // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
-  SirtRef<Class> java_lang_reflect_Constructor(self, AllocClass(java_lang_Class.get(),
-                                                          sizeof(MethodClass)));
+  SirtRef<Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
+                                                                sizeof(MethodClass)));
   CHECK(java_lang_reflect_Constructor.get() != NULL);
   java_lang_reflect_Constructor->SetObjectSize(sizeof(Constructor));
   SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
   java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
 
-  SirtRef<Class> java_lang_reflect_Field(self, AllocClass(java_lang_Class.get(), sizeof(FieldClass)));
+  SirtRef<Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
+                                                          sizeof(FieldClass)));
   CHECK(java_lang_reflect_Field.get() != NULL);
   java_lang_reflect_Field->SetObjectSize(sizeof(Field));
   SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
   java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
   Field::SetClass(java_lang_reflect_Field.get());
 
-  SirtRef<Class> java_lang_reflect_Method(self, AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
+  SirtRef<Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
+                                                           sizeof(MethodClass)));
   CHECK(java_lang_reflect_Method.get() != NULL);
   java_lang_reflect_Method->SetObjectSize(sizeof(Method));
   SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
   java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
 
-  SirtRef<Class> java_lang_reflect_AbstractMethod(self, AllocClass(java_lang_Class.get(),
-                                                             sizeof(MethodClass)));
+  SirtRef<Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
+                                                                   sizeof(MethodClass)));
   CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
   java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(AbstractMethod));
   SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
@@ -342,15 +346,15 @@
   AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
 
   // Set up array classes for string, field, method
-  SirtRef<Class> object_array_string(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   object_array_string->SetComponentType(java_lang_String.get());
   SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
 
-  SirtRef<Class> object_array_field(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   object_array_field->SetComponentType(java_lang_reflect_Field.get());
   SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
 
-  SirtRef<Class> object_array_abstract_method(self, AllocClass(java_lang_Class.get(), sizeof(Class)));
+  SirtRef<Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
   object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
   SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
 
@@ -426,8 +430,8 @@
   CHECK(java_io_Serializable != NULL);
   // We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
   // crawl up and explicitly list all of the supers as well.
-  array_iftable_->Set(0, AllocInterfaceEntry(java_lang_Cloneable));
-  array_iftable_->Set(1, AllocInterfaceEntry(java_io_Serializable));
+  array_iftable_->Set(0, AllocInterfaceEntry(self, java_lang_Cloneable));
+  array_iftable_->Set(1, AllocInterfaceEntry(self, java_io_Serializable));
 
   // Sanity check Class[] and Object[]'s interfaces.
   ClassHelper kh(class_array_class.get(), this);
@@ -667,17 +671,17 @@
 }
 
 void ClassLinker::RegisterOatFile(const OatFile& oat_file) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   RegisterOatFileLocked(oat_file);
 }
 
 void ClassLinker::RegisterOatFileLocked(const OatFile& oat_file) {
-  dex_lock_.AssertHeld();
+  dex_lock_.AssertHeld(Thread::Current());
   oat_files_.push_back(&oat_file);
 }
 
 OatFile* ClassLinker::OpenOat(const ImageSpace* space) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   const Runtime* runtime = Runtime::Current();
   const ImageHeader& image_header = space->GetImageHeader();
   // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
@@ -708,7 +712,7 @@
 }
 
 const OatFile* ClassLinker::FindOpenedOatFileForDexFile(const DexFile& dex_file) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   return FindOpenedOatFileFromDexLocation(dex_file.GetLocation());
 }
 
@@ -750,7 +754,7 @@
 
 const DexFile* ClassLinker::FindOrCreateOatFileForDexLocation(const std::string& dex_location,
                                                               const std::string& oat_location) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   return FindOrCreateOatFileForDexLocationLocked(dex_location, oat_location);
 }
 
@@ -855,7 +859,7 @@
 }
 
 const DexFile* ClassLinker::FindDexFileInOatFileFromDexLocation(const std::string& dex_location) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
 
   const OatFile* open_oat_file = FindOpenedOatFileFromDexLocation(dex_location);
   if (open_oat_file != NULL) {
@@ -922,7 +926,7 @@
 }
 
 const OatFile* ClassLinker::FindOatFileFromOatLocation(const std::string& oat_location) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   return FindOatFileFromOatLocationLocked(oat_location);
 }
 
@@ -980,7 +984,7 @@
 
   // reinit clases_ table
   {
-    ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+    ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
     heap->FlushAllocStack();
     heap->GetLiveBitmap()->Walk(InitFromImageCallback, this);
   }
@@ -1037,16 +1041,16 @@
 // mapped image.
 void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
   visitor(class_roots_, arg);
-
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(dex_lock_);
+    MutexLock mu(self, dex_lock_);
     for (size_t i = 0; i < dex_caches_.size(); i++) {
       visitor(dex_caches_[i], arg);
     }
   }
 
   {
-    MutexLock mu(*Locks::classlinker_classes_lock_);
+    MutexLock mu(self, *Locks::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);
@@ -1060,7 +1064,7 @@
 }
 
 void ClassLinker::VisitClasses(ClassVisitor* visitor, void* arg) const {
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::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)) {
@@ -1110,13 +1114,12 @@
   STLDeleteElements(&oat_files_);
 }
 
-DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
+DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
   Heap* heap = Runtime::Current()->GetHeap();
   Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
-  Thread* self = Thread::Current();
-  SirtRef<DexCache> dex_cache(
-      self,
-      down_cast<DexCache*>(heap->AllocObject(dex_cache_class, dex_cache_class->GetObjectSize())));
+  SirtRef<DexCache> dex_cache(self,
+                              down_cast<DexCache*>(heap->AllocObject(self, dex_cache_class,
+                              dex_cache_class->GetObjectSize())));
   if (dex_cache.get() == NULL) {
     return NULL;
   }
@@ -1124,24 +1127,26 @@
   if (location.get() == NULL) {
     return NULL;
   }
-  SirtRef<ObjectArray<String> > strings(self, AllocStringArray(dex_file.NumStringIds()));
+  SirtRef<ObjectArray<String> > strings(self, AllocStringArray(self, dex_file.NumStringIds()));
   if (strings.get() == NULL) {
     return NULL;
   }
-  SirtRef<ObjectArray<Class> > types(self, AllocClassArray(dex_file.NumTypeIds()));
+  SirtRef<ObjectArray<Class> > types(self, AllocClassArray(self, dex_file.NumTypeIds()));
   if (types.get() == NULL) {
     return NULL;
   }
-  SirtRef<ObjectArray<AbstractMethod> > methods(self, AllocMethodArray(dex_file.NumMethodIds()));
+  SirtRef<ObjectArray<AbstractMethod> >
+      methods(self, AllocMethodArray(self, dex_file.NumMethodIds()));
   if (methods.get() == NULL) {
     return NULL;
   }
-  SirtRef<ObjectArray<Field> > fields(self, AllocFieldArray(dex_file.NumFieldIds()));
+  SirtRef<ObjectArray<Field> > fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
   if (fields.get() == NULL) {
     return NULL;
   }
   SirtRef<ObjectArray<StaticStorageBase> >
-      initialized_static_storage(self, AllocObjectArray<StaticStorageBase>(dex_file.NumTypeIds()));
+      initialized_static_storage(self,
+                                 AllocObjectArray<StaticStorageBase>(self, dex_file.NumTypeIds()));
   if (initialized_static_storage.get() == NULL) {
     return NULL;
   }
@@ -1156,52 +1161,51 @@
   return dex_cache.get();
 }
 
-InterfaceEntry* ClassLinker::AllocInterfaceEntry(Class* interface) {
+InterfaceEntry* ClassLinker::AllocInterfaceEntry(Thread* self, Class* interface) {
   DCHECK(interface->IsInterface());
-  Thread* self = Thread::Current();
-  SirtRef<ObjectArray<Object> > array(self, AllocObjectArray<Object>(InterfaceEntry::LengthAsArray()));
+  SirtRef<ObjectArray<Object> > array(self, AllocObjectArray<Object>(self, InterfaceEntry::LengthAsArray()));
   SirtRef<InterfaceEntry> interface_entry(self, down_cast<InterfaceEntry*>(array.get()));
   interface_entry->SetInterface(interface);
   return interface_entry.get();
 }
 
-Class* ClassLinker::AllocClass(Class* java_lang_Class, size_t class_size) {
+Class* ClassLinker::AllocClass(Thread* self, Class* java_lang_Class, size_t class_size) {
   DCHECK_GE(class_size, sizeof(Class));
   Heap* heap = Runtime::Current()->GetHeap();
-  SirtRef<Class> klass(Thread::Current(),
-                       heap->AllocObject(java_lang_Class, class_size)->AsClass());
+  SirtRef<Class> klass(self,
+                       heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
   klass->SetPrimitiveType(Primitive::kPrimNot);  // default to not being primitive
   klass->SetClassSize(class_size);
   return klass.get();
 }
 
-Class* ClassLinker::AllocClass(size_t class_size) {
-  return AllocClass(GetClassRoot(kJavaLangClass), class_size);
+Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
+  return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
 }
 
-Field* ClassLinker::AllocField() {
-  return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject());
+Field* ClassLinker::AllocField(Thread* self) {
+  return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
 }
 
-Method* ClassLinker::AllocMethod() {
-  return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject());
+Method* ClassLinker::AllocMethod(Thread* self) {
+  return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
 }
 
-Constructor* ClassLinker::AllocConstructor() {
-  return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject());
+Constructor* ClassLinker::AllocConstructor(Thread* self) {
+  return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
 }
 
-ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(size_t length) {
-  return ObjectArray<StackTraceElement>::Alloc(
-      GetClassRoot(kJavaLangStackTraceElementArrayClass),
-      length);
+ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
+                                                                         size_t length) {
+  return ObjectArray<StackTraceElement>::Alloc(self,
+                                               GetClassRoot(kJavaLangStackTraceElementArrayClass),
+                                               length);
 }
 
-static Class* EnsureResolved(Class* klass)
+static Class* EnsureResolved(Thread* self, Class* klass)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(klass != NULL);
   // Wait for the class if it has not already been linked.
-  Thread* self = Thread::Current();
   if (!klass->IsResolved() && !klass->IsErroneous()) {
     ObjectLock lock(self, klass);
     // Check for circular dependencies between classes.
@@ -1245,7 +1249,7 @@
   // Find the class in the loaded classes table.
   Class* klass = LookupClass(descriptor, class_loader);
   if (klass != NULL) {
-    return EnsureResolved(klass);
+    return EnsureResolved(self, klass);
   }
   // Class is not yet loaded.
   if (descriptor[0] == '[') {
@@ -1341,10 +1345,10 @@
     } else if (descriptor == "Ljava/lang/reflect/Method;") {
       klass.reset(GetClassRoot(kJavaLangReflectMethod));
     } else {
-      klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
+      klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
     }
   } else {
-    klass.reset(AllocClass(SizeOfClass(dex_file, dex_class_def)));
+    klass.reset(AllocClass(self, SizeOfClass(dex_file, dex_class_def)));
   }
   klass->SetDexCache(FindDexCache(dex_file));
   LoadClass(dex_file, dex_class_def, klass, class_loader);
@@ -1359,7 +1363,7 @@
   SirtRef<Class> existing(self, InsertClass(descriptor, klass.get(), false));
   if (existing.get() != NULL) {
     // We failed to insert because we raced with another thread.
-    return EnsureResolved(existing.get());
+    return EnsureResolved(self, existing.get());
   }
   // Finish loading (if necessary) by finding parents
   CHECK(!klass->IsLoaded());
@@ -1588,20 +1592,20 @@
     return;  // no fields or methods - for example a marker interface
   }
   ClassDataItemIterator it(dex_file, class_data);
+  Thread* self = Thread::Current();
   if (it.NumStaticFields() != 0) {
-    klass->SetSFields(AllocObjectArray<Field>(it.NumStaticFields()));
+    klass->SetSFields(AllocObjectArray<Field>(self, it.NumStaticFields()));
   }
   if (it.NumInstanceFields() != 0) {
-    klass->SetIFields(AllocObjectArray<Field>(it.NumInstanceFields()));
+    klass->SetIFields(AllocObjectArray<Field>(self, it.NumInstanceFields()));
   }
-  Thread* self = Thread::Current();
   for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
-    SirtRef<Field> sfield(self, AllocField());
+    SirtRef<Field> sfield(self, AllocField(self));
     klass->SetStaticField(i, sfield.get());
     LoadField(dex_file, it, klass, sfield);
   }
   for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
-    SirtRef<Field> ifield(self, AllocField());
+    SirtRef<Field> ifield(self, AllocField(self));
     klass->SetInstanceField(i, ifield.get());
     LoadField(dex_file, it, klass, ifield);
   }
@@ -1614,15 +1618,15 @@
   // Load methods.
   if (it.NumDirectMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(it.NumDirectMethods()));
+    klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(self, it.NumDirectMethods()));
   }
   if (it.NumVirtualMethods() != 0) {
     // TODO: append direct methods to class object
-    klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(it.NumVirtualMethods()));
+    klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(self, it.NumVirtualMethods()));
   }
   size_t class_def_method_index = 0;
   for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
-    SirtRef<AbstractMethod> method(self, LoadMethod(dex_file, it, klass));
+    SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
     klass->SetDirectMethod(i, method.get());
     if (oat_class.get() != NULL) {
       LinkCode(method, oat_class.get(), class_def_method_index);
@@ -1631,7 +1635,7 @@
     class_def_method_index++;
   }
   for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
-    SirtRef<AbstractMethod> method(self, LoadMethod(dex_file, it, klass));
+    SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
     klass->SetVirtualMethod(i, method.get());
     DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
     if (oat_class.get() != NULL) {
@@ -1650,21 +1654,22 @@
   dst->SetAccessFlags(it.GetMemberAccessFlags());
 }
 
-AbstractMethod* ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
-                             SirtRef<Class>& klass) {
+AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
+                                        const ClassDataItemIterator& it,
+                                        SirtRef<Class>& klass) {
   uint32_t dex_method_idx = it.GetMemberIndex();
   const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
   StringPiece method_name(dex_file.GetMethodName(method_id));
 
   AbstractMethod* dst = NULL;
   if (method_name == "<init>") {
-    dst = AllocConstructor();
+    dst = AllocConstructor(self);
   } else {
-    dst = AllocMethod();
+    dst = AllocMethod(self);
   }
   DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
 
-  const char* old_cause = Thread::Current()->StartAssertNoThreadSuspension("LoadMethod");
+  const char* old_cause = self->StartAssertNoThreadSuspension("LoadMethod");
   dst->SetDexMethodIndex(dex_method_idx);
   dst->SetDeclaringClass(klass.get());
 
@@ -1708,12 +1713,13 @@
 
   CHECK(dst->IsMethod());
 
-  Thread::Current()->EndAssertNoThreadSuspension(old_cause);
+  self->EndAssertNoThreadSuspension(old_cause);
   return dst;
 }
 
 void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
-  SirtRef<DexCache> dex_cache(Thread::Current(), AllocDexCache(dex_file));
+  Thread* self = Thread::Current();
+  SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
   AppendToBootClassPath(dex_file, dex_cache);
 }
 
@@ -1724,7 +1730,7 @@
 }
 
 bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
-  dex_lock_.AssertHeld();
+  dex_lock_.AssertHeld(Thread::Current());
   for (size_t i = 0; i != dex_caches_.size(); ++i) {
     if (dex_caches_[i]->GetDexFile() == &dex_file) {
       return true;
@@ -1734,12 +1740,12 @@
 }
 
 bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   return IsDexFileRegisteredLocked(dex_file);
 }
 
 void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
-  dex_lock_.AssertHeld();
+  dex_lock_.AssertHeld(Thread::Current());
   CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
   CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
   dex_caches_.push_back(dex_cache.get());
@@ -1757,7 +1763,7 @@
   // Don't alloc while holding the lock, since allocation may need to
   // suspend all threads and another thread may need the dex_lock_ to
   // get to a suspend point.
-  SirtRef<DexCache> dex_cache(self, AllocDexCache(dex_file));
+  SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
   {
     MutexLock mu(self, dex_lock_);
     if (IsDexFileRegisteredLocked(dex_file)) {
@@ -1768,7 +1774,7 @@
 }
 
 void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   RegisterDexFileLocked(dex_file, dex_cache);
 }
 
@@ -1783,7 +1789,7 @@
 }
 
 DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   for (size_t i = 0; i != dex_caches_.size(); ++i) {
     DexCache* dex_cache = dex_caches_[i];
     if (dex_cache->GetDexFile() == &dex_file) {
@@ -1795,7 +1801,7 @@
 }
 
 void ClassLinker::FixupDexCaches(AbstractMethod* resolution_method) const {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   for (size_t i = 0; i != dex_caches_.size(); ++i) {
     dex_caches_[i]->Fixup(resolution_method);
   }
@@ -1891,7 +1897,7 @@
     }
   }
   if (new_class.get() == NULL) {
-    new_class.reset(AllocClass(sizeof(Class)));
+    new_class.reset(AllocClass(self, sizeof(Class)));
     if (new_class.get() == NULL) {
       return NULL;
     }
@@ -1986,7 +1992,7 @@
     LOG(INFO) << "Loaded class " << descriptor << source;
   }
   size_t hash = StringPieceHash()(descriptor);
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
   Table& classes = image_class ? image_classes_ : classes_;
   Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
 #ifndef NDEBUG
@@ -2003,7 +2009,7 @@
 
 bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::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;
@@ -2028,7 +2034,7 @@
 
 Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
   size_t hash = Hash(descriptor);
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::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) {
@@ -2063,7 +2069,7 @@
 void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
   classes.clear();
   size_t hash = Hash(descriptor);
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::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);
@@ -2295,7 +2301,8 @@
                                      ClassLoader* loader, ObjectArray<AbstractMethod>* methods,
                                      ObjectArray<ObjectArray<Class> >* throws) {
   Thread* self = Thread::Current();
-  SirtRef<Class> klass(self, AllocClass(GetClassRoot(kJavaLangClass), sizeof(SynthesizedProxyClass)));
+  SirtRef<Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
+                                        sizeof(SynthesizedProxyClass)));
   CHECK(klass.get() != NULL);
   DCHECK(klass->GetClass() != NULL);
   klass->SetObjectSize(sizeof(Proxy));
@@ -2311,31 +2318,31 @@
   klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
 
   // Instance fields are inherited, but we add a couple of static fields...
-  klass->SetSFields(AllocObjectArray<Field>(2));
+  klass->SetSFields(AllocObjectArray<Field>(self, 2));
   // 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
   // our proxy, so Class.getInterfaces doesn't return the flattened set.
-  SirtRef<Field> interfaces_sfield(self, AllocField());
+  SirtRef<Field> interfaces_sfield(self, AllocField(self));
   klass->SetStaticField(0, interfaces_sfield.get());
   interfaces_sfield->SetDexFieldIndex(0);
   interfaces_sfield->SetDeclaringClass(klass.get());
   interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
   // 2. Create a static field 'throws' that holds exceptions thrown by our methods.
-  SirtRef<Field> throws_sfield(self, AllocField());
+  SirtRef<Field> throws_sfield(self, AllocField(self));
   klass->SetStaticField(1, throws_sfield.get());
   throws_sfield->SetDexFieldIndex(1);
   throws_sfield->SetDeclaringClass(klass.get());
   throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
 
   // Proxies have 1 direct method, the constructor
-  klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(1));
-  klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
+  klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(self, 1));
+  klass->SetDirectMethod(0, CreateProxyConstructor(self, klass, proxy_class));
 
   // Create virtual method using specified prototypes
   size_t num_virtual_methods = methods->GetLength();
-  klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(num_virtual_methods));
+  klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(self, num_virtual_methods));
   for (size_t i = 0; i < num_virtual_methods; ++i) {
     SirtRef<AbstractMethod> prototype(self, methods->Get(i));
-    klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
+    klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
   }
 
   klass->SetSuperClass(proxy_class);  // The super class is java.lang.reflect.Proxy
@@ -2392,7 +2399,7 @@
   DexCache* dex_cache = NULL;
   {
     ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
-    MutexLock mu(dex_lock_);
+    MutexLock mu(Thread::Current(), dex_lock_);
     for (size_t i = 0; i != dex_caches_.size(); ++i) {
       if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
         dex_cache = dex_caches_[i];
@@ -2408,14 +2415,14 @@
 }
 
 
-AbstractMethod* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
+AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class) {
   // Create constructor for Proxy that must initialize h
   ObjectArray<AbstractMethod>* proxy_direct_methods = proxy_class->GetDirectMethods();
   CHECK_EQ(proxy_direct_methods->GetLength(), 15);
   AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
   // Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
   // code_ too)
-  AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone());
+  AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone(self));
   // Make this constructor public and fix the class to be our Proxy version
   constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
   constructor->SetDeclaringClass(klass.get());
@@ -2431,14 +2438,15 @@
   DCHECK(constructor->IsPublic());
 }
 
-AbstractMethod* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<AbstractMethod>& prototype) {
+AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
+                                               SirtRef<AbstractMethod>& prototype) {
   // Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
   // prototype method
   prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
                                                                    prototype.get());
   // We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
   // as necessary
-  AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone());
+  AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone(self));
 
   // Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
   // the intersection of throw exceptions as defined in Proxy
@@ -2980,7 +2988,7 @@
     CHECK_LE(actual_count, max_count);
     // TODO: do not assign to the vtable field until it is fully constructed.
     SirtRef<ObjectArray<AbstractMethod> >
-        vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(max_count));
+      vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
     // See if any of our virtual methods override the superclass.
     MethodHelper local_mh(NULL, this);
     MethodHelper super_mh(NULL, this);
@@ -3023,7 +3031,7 @@
     // Shrink vtable if possible
     CHECK_LE(actual_count, max_count);
     if (actual_count < max_count) {
-      vtable.reset(vtable->CopyOf(actual_count));
+      vtable.reset(vtable->CopyOf(self, actual_count));
     }
     klass->SetVTable(vtable.get());
   } else {
@@ -3034,7 +3042,7 @@
       return false;
     }
     SirtRef<ObjectArray<AbstractMethod> >
-        vtable(self, AllocObjectArray<AbstractMethod>(num_virtual_methods));
+        vtable(self, AllocObjectArray<AbstractMethod>(self, num_virtual_methods));
     for (size_t i = 0; i < num_virtual_methods; ++i) {
       AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
       vtable->Set(i, virtual_method);
@@ -3067,12 +3075,12 @@
     return true;
   }
   Thread* self = Thread::Current();
-  SirtRef<ObjectArray<InterfaceEntry> > iftable(self, AllocIfTable(ifcount));
+  SirtRef<ObjectArray<InterfaceEntry> > iftable(self, AllocIfTable(self, ifcount));
   if (super_ifcount != 0) {
     ObjectArray<InterfaceEntry>* super_iftable = klass->GetSuperClass()->GetIfTable();
     for (size_t i = 0; i < super_ifcount; i++) {
       Class* super_interface = super_iftable->Get(i)->GetInterface();
-      iftable->Set(i, AllocInterfaceEntry(super_interface));
+      iftable->Set(i, AllocInterfaceEntry(self, super_interface));
     }
   }
   // Flatten the interface inheritance hierarchy.
@@ -3099,7 +3107,7 @@
     }
     if (!duplicate) {
       // Add this non-duplicate interface.
-      iftable->Set(idx++, AllocInterfaceEntry(interface));
+      iftable->Set(idx++, AllocInterfaceEntry(self, interface));
       // Add this interface's non-duplicate super-interfaces.
       for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
         Class* super_interface = interface->GetIfTable()->Get(j)->GetInterface();
@@ -3112,14 +3120,14 @@
           }
         }
         if (!super_duplicate) {
-          iftable->Set(idx++, AllocInterfaceEntry(super_interface));
+          iftable->Set(idx++, AllocInterfaceEntry(self, super_interface));
         }
       }
     }
   }
   // Shrink iftable in case duplicates were found
   if (idx < ifcount) {
-    iftable.reset(iftable->CopyOf(idx));
+    iftable.reset(iftable->CopyOf(self, idx));
     ifcount = idx;
   } else {
     CHECK_EQ(idx, ifcount);
@@ -3136,7 +3144,8 @@
   for (size_t i = 0; i < ifcount; ++i) {
     InterfaceEntry* interface_entry = iftable->Get(i);
     Class* interface = interface_entry->GetInterface();
-    ObjectArray<AbstractMethod>* method_array = AllocObjectArray<AbstractMethod>(interface->NumVirtualMethods());
+    ObjectArray<AbstractMethod>* method_array =
+        AllocObjectArray<AbstractMethod>(self, interface->NumVirtualMethods());
     interface_entry->SetMethodArray(method_array);
     ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
     for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
@@ -3176,7 +3185,7 @@
         }
         if (miranda_method.get() == NULL) {
           // point the interface table at a phantom slot
-          miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone()));
+          miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone(self)));
           miranda_list.push_back(miranda_method.get());
         }
         method_array->Set(j, miranda_method.get());
@@ -3187,14 +3196,14 @@
     int old_method_count = klass->NumVirtualMethods();
     int new_method_count = old_method_count + miranda_list.size();
     klass->SetVirtualMethods((old_method_count == 0)
-                             ? AllocObjectArray<AbstractMethod>(new_method_count)
-                             : klass->GetVirtualMethods()->CopyOf(new_method_count));
+                             ? AllocObjectArray<AbstractMethod>(self, new_method_count)
+                             : klass->GetVirtualMethods()->CopyOf(self, new_method_count));
 
     SirtRef<ObjectArray<AbstractMethod> > vtable(self, klass->GetVTableDuringLinking());
     CHECK(vtable.get() != NULL);
     int old_vtable_count = vtable->GetLength();
     int new_vtable_count = old_vtable_count + miranda_list.size();
-    vtable.reset(vtable->CopyOf(new_vtable_count));
+    vtable.reset(vtable->CopyOf(self, new_vtable_count));
     for (size_t i = 0; i < miranda_list.size(); ++i) {
       AbstractMethod* method = miranda_list[i];
       // Leave the declaring class alone as type indices are relative to it
@@ -3730,7 +3739,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(*Locks::classlinker_classes_lock_);
+    MutexLock mu(Thread::Current(), *Locks::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);
@@ -3746,13 +3755,13 @@
 }
 
 void ClassLinker::DumpForSigQuit(std::ostream& os) const {
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
   os << "Loaded classes: " << image_classes_.size() << " image classes; "
      << classes_.size() << " allocated classes\n";
 }
 
 size_t ClassLinker::NumLoadedClasses() const {
-  MutexLock mu(*Locks::classlinker_classes_lock_);
+  MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
   return classes_.size() + image_classes_.size();
 }
 
@@ -3776,7 +3785,7 @@
 }
 
 void ClassLinker::RelocateExecutable() {
-  MutexLock mu(dex_lock_);
+  MutexLock mu(Thread::Current(), dex_lock_);
   for (size_t i = 0; i < oat_files_.size(); ++i) {
     const_cast<OatFile*>(oat_files_[i])->RelocateExecutable();
   }
diff --git a/src/class_linker.h b/src/class_linker.h
index b07157a..38b402f 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -313,38 +313,38 @@
 
   // TODO: replace this with multiple methods that allocate the correct managed type.
   template <class T>
-  ObjectArray<T>* AllocObjectArray(size_t length)
+  ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<T>::Alloc(GetClassRoot(kObjectArrayClass), length);
+    return ObjectArray<T>::Alloc(self, GetClassRoot(kObjectArrayClass), length);
   }
 
-  ObjectArray<Class>* AllocClassArray(size_t length)
+  ObjectArray<Class>* AllocClassArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<Class>::Alloc(GetClassRoot(kClassArrayClass), length);
+    return ObjectArray<Class>::Alloc(self, GetClassRoot(kClassArrayClass), length);
   }
 
-  ObjectArray<String>* AllocStringArray(size_t length)
+  ObjectArray<String>* AllocStringArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<String>::Alloc(GetClassRoot(kJavaLangStringArrayClass), length);
+    return ObjectArray<String>::Alloc(self, GetClassRoot(kJavaLangStringArrayClass), length);
   }
 
-  ObjectArray<AbstractMethod>* AllocMethodArray(size_t length)
+  ObjectArray<AbstractMethod>* AllocMethodArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<AbstractMethod>::Alloc(
+    return ObjectArray<AbstractMethod>::Alloc(self,
         GetClassRoot(kJavaLangReflectAbstractMethodArrayClass), length);
   }
 
-  ObjectArray<InterfaceEntry>* AllocIfTable(size_t length)
+  ObjectArray<InterfaceEntry>* AllocIfTable(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<InterfaceEntry>::Alloc(GetClassRoot(kObjectArrayArrayClass), length);
+    return ObjectArray<InterfaceEntry>::Alloc(self, GetClassRoot(kObjectArrayArrayClass), length);
   }
 
-  ObjectArray<Field>* AllocFieldArray(size_t length)
+  ObjectArray<Field>* AllocFieldArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return ObjectArray<Field>::Alloc(GetClassRoot(kJavaLangReflectFieldArrayClass), length);
+    return ObjectArray<Field>::Alloc(self, GetClassRoot(kJavaLangReflectFieldArrayClass), length);
   }
 
-  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length)
+  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void VerifyClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -396,25 +396,25 @@
   void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // For early bootstrapping by Init
-  Class* AllocClass(Class* java_lang_Class, size_t class_size)
+  Class* AllocClass(Thread* self, Class* java_lang_Class, size_t class_size)
       SHARED_LOCKS_REQUIRED(Locks::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) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  DexCache* AllocDexCache(const DexFile& dex_file)
+  Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  Field* AllocField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  Method* AllocMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  Constructor* AllocConstructor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  InterfaceEntry* AllocInterfaceEntry(Class* interface)
+  InterfaceEntry* AllocInterfaceEntry(Thread* self, Class* interface)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Class* CreatePrimitiveClass(Primitive::Type type)
+  Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return InitializePrimitiveClass(AllocClass(sizeof(Class)), type);
+    return InitializePrimitiveClass(AllocClass(self, sizeof(Class)), type);
   }
   Class* InitializePrimitiveClass(Class* primitive_class, Primitive::Type type)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -444,8 +444,9 @@
   void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
                  SirtRef<Field>& dst) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& dex_method,
-                  SirtRef<Class>& klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
+                             const ClassDataItemIterator& dex_method,
+                             SirtRef<Class>& klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   void FixupStaticTrampolines(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
@@ -538,9 +539,10 @@
       EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  AbstractMethod* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class)
+  AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  AbstractMethod* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<AbstractMethod>& prototype)
+  AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
+                                    SirtRef<AbstractMethod>& prototype)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   std::vector<const DexFile*> boot_class_path_;
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index d0b9e16..02512eb 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -773,7 +773,7 @@
 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);
+  ObjectArray<String>* array = ObjectArray<String>::Alloc(soa.Self(), array_class, 0);
   uint32_t array_offset = reinterpret_cast<uint32_t>(array);
   uint32_t data_offset =
       array_offset + ObjectArray<String>::DataOffset(sizeof(String*)).Uint32Value();
@@ -786,27 +786,27 @@
 
 TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<LongArray> long_array(soa.Self(), LongArray::Alloc(0));
+  SirtRef<LongArray> long_array(soa.Self(), LongArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[J"), long_array->GetClass());
   uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData());
   EXPECT_TRUE(IsAligned<8>(data_offset));  // Longs require 8 byte alignment
 
-  SirtRef<DoubleArray> double_array(soa.Self(), DoubleArray::Alloc(0));
+  SirtRef<DoubleArray> double_array(soa.Self(), DoubleArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[D"), double_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(double_array->GetData());
   EXPECT_TRUE(IsAligned<8>(data_offset));  // Doubles require 8 byte alignment
 
-  SirtRef<IntArray> int_array(soa.Self(), IntArray::Alloc(0));
+  SirtRef<IntArray> int_array(soa.Self(), IntArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[I"), int_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(int_array->GetData());
   EXPECT_TRUE(IsAligned<4>(data_offset));  // Ints require 4 byte alignment
 
-  SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(0));
+  SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[C"), char_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(char_array->GetData());
   EXPECT_TRUE(IsAligned<2>(data_offset));  // Chars require 2 byte alignment
 
-  SirtRef<ShortArray> short_array(soa.Self(), ShortArray::Alloc(0));
+  SirtRef<ShortArray> short_array(soa.Self(), ShortArray::Alloc(soa.Self(), 0));
   EXPECT_EQ(class_linker_->FindSystemClass("[S"), short_array->GetClass());
   data_offset = reinterpret_cast<uintptr_t>(short_array->GetData());
   EXPECT_TRUE(IsAligned<2>(data_offset));  // Shorts require 2 byte alignment
@@ -923,7 +923,7 @@
   fh.ChangeField(s8);
   EXPECT_TRUE(fh.GetTypeAsPrimitiveType() == Primitive::kPrimNot);
   EXPECT_TRUE(s8->GetObject(NULL)->AsString()->Equals("android"));
-  s8->SetObject(NULL, String::AllocFromModifiedUtf8("robot"));
+  s8->SetObject(NULL, String::AllocFromModifiedUtf8(soa.Self(), "robot"));
 
   // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
   // http://code.google.com/p/googletest/issues/detail?id=322
diff --git a/src/compiler.cc b/src/compiler.cc
index 10b4939..3899ce9 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -34,6 +34,7 @@
 #include "scoped_thread_state_change.h"
 #include "ScopedLocalRef.h"
 #include "stl_util.h"
+#include "thread.h"
 #include "timing_logger.h"
 #include "verifier/method_verifier.h"
 
@@ -110,9 +111,9 @@
     }
   }
 
-// Allow lossy statistics in non-debug builds
+// Allow lossy statistics in non-debug builds.
 #ifndef NDEBUG
-#define STATS_LOCK() MutexLock mu(stats_lock_)
+#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
 #else
 #define STATS_LOCK()
 #endif
@@ -359,30 +360,31 @@
 }
 
 Compiler::~Compiler() {
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(compiled_classes_lock_);
+    MutexLock mu(self, compiled_classes_lock_);
     STLDeleteValues(&compiled_classes_);
   }
   {
-    MutexLock mu(compiled_methods_lock_);
+    MutexLock mu(self, compiled_methods_lock_);
     STLDeleteValues(&compiled_methods_);
   }
   {
-    MutexLock mu(compiled_invoke_stubs_lock_);
+    MutexLock mu(self, compiled_invoke_stubs_lock_);
     STLDeleteValues(&compiled_invoke_stubs_);
   }
 #if defined(ART_USE_LLVM_COMPILER)
   {
-    MutexLock mu(compiled_proxy_stubs_lock_);
+    MutexLock mu(self, compiled_proxy_stubs_lock_);
     STLDeleteValues(&compiled_proxy_stubs_);
   }
 #endif
   {
-    MutexLock mu(compiled_methods_lock_);
+    MutexLock mu(self, compiled_methods_lock_);
     STLDeleteElements(&code_to_patch_);
   }
   {
-    MutexLock mu(compiled_methods_lock_);
+    MutexLock mu(self, compiled_methods_lock_);
     STLDeleteElements(&methods_to_patch_);
   }
 #if defined(ART_USE_LLVM_COMPILER)
@@ -554,7 +556,7 @@
 }
 
 void Compiler::RecordClassStatus(ClassReference ref, CompiledClass* compiled_class) {
-  MutexLock mu(Compiler::compiled_classes_lock_);
+  MutexLock mu(Thread::Current(), Compiler::compiled_classes_lock_);
   compiled_classes_.Put(ref, compiled_class);
 }
 
@@ -929,7 +931,7 @@
                             uint32_t target_method_idx,
                             InvokeType target_invoke_type,
                             size_t literal_offset) {
-  MutexLock mu(compiled_methods_lock_);
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
   code_to_patch_.push_back(new PatchInformation(dex_file,
                                                 referrer_method_idx,
                                                 referrer_invoke_type,
@@ -943,7 +945,7 @@
                               uint32_t target_method_idx,
                               InvokeType target_invoke_type,
                               size_t literal_offset) {
-  MutexLock mu(compiled_methods_lock_);
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
   methods_to_patch_.push_back(new PatchInformation(dex_file,
                                                    referrer_method_idx,
                                                    referrer_invoke_type,
@@ -1068,10 +1070,7 @@
 
   // 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(*Locks::thread_suspend_count_lock_);
-    CHECK_NE(self->GetState(), kRunnable);
-  }
+  CHECK_NE(self->GetState(), kRunnable);
   STLDeleteElements(&threads);
 }
 
@@ -1427,11 +1426,12 @@
                  << " took " << PrettyDuration(duration_ns);
   }
 
+  Thread* self = Thread::Current();
   if (compiled_method != NULL) {
     MethodReference ref(&dex_file, method_idx);
     CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
     {
-      MutexLock mu(compiled_methods_lock_);
+      MutexLock mu(self, compiled_methods_lock_);
       compiled_methods_.Put(ref, compiled_method);
     }
     DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
@@ -1459,10 +1459,10 @@
   }
 #endif
 
-  if (Thread::Current()->IsExceptionPending()) {
-    ScopedObjectAccess soa(Thread::Current());
+  if (self->IsExceptionPending()) {
+    ScopedObjectAccess soa(self);
     LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
-        << Thread::Current()->GetException()->Dump();
+        << self->GetException()->Dump();
   }
 }
 
@@ -1472,7 +1472,7 @@
 }
 
 const CompiledInvokeStub* Compiler::FindInvokeStub(const std::string& key) const {
-  MutexLock mu(compiled_invoke_stubs_lock_);
+  MutexLock mu(Thread::Current(), compiled_invoke_stubs_lock_);
   InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(key);
   if (it == compiled_invoke_stubs_.end()) {
     return NULL;
@@ -1484,7 +1484,7 @@
 
 void Compiler::InsertInvokeStub(const std::string& key,
                                 const CompiledInvokeStub* compiled_invoke_stub) {
-  MutexLock mu(compiled_invoke_stubs_lock_);
+  MutexLock mu(Thread::Current(), compiled_invoke_stubs_lock_);
   InvokeStubTable::iterator it = compiled_invoke_stubs_.find(key);
   if (it != compiled_invoke_stubs_.end()) {
     // Someone else won the race.
@@ -1496,7 +1496,7 @@
 
 #if defined(ART_USE_LLVM_COMPILER)
 const CompiledInvokeStub* Compiler::FindProxyStub(const char* shorty) const {
-  MutexLock mu(compiled_proxy_stubs_lock_);
+  MutexLock mu(Thread::Current(), compiled_proxy_stubs_lock_);
   ProxyStubTable::const_iterator it = compiled_proxy_stubs_.find(shorty);
   if (it == compiled_proxy_stubs_.end()) {
     return NULL;
@@ -1508,7 +1508,7 @@
 
 void Compiler::InsertProxyStub(const char* shorty,
                                const CompiledInvokeStub* compiled_proxy_stub) {
-  MutexLock mu(compiled_proxy_stubs_lock_);
+  MutexLock mu(Thread::Current(), compiled_proxy_stubs_lock_);
   InvokeStubTable::iterator it = compiled_proxy_stubs_.find(shorty);
   if (it != compiled_proxy_stubs_.end()) {
     // Someone else won the race.
@@ -1520,7 +1520,7 @@
 #endif
 
 CompiledClass* Compiler::GetCompiledClass(ClassReference ref) const {
-  MutexLock mu(compiled_classes_lock_);
+  MutexLock mu(Thread::Current(), compiled_classes_lock_);
   ClassTable::const_iterator it = compiled_classes_.find(ref);
   if (it == compiled_classes_.end()) {
     return NULL;
@@ -1530,7 +1530,7 @@
 }
 
 CompiledMethod* Compiler::GetCompiledMethod(MethodReference ref) const {
-  MutexLock mu(compiled_methods_lock_);
+  MutexLock mu(Thread::Current(), compiled_methods_lock_);
   MethodTable::const_iterator it = compiled_methods_.find(ref);
   if (it == compiled_methods_.end()) {
     return NULL;
diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
index f65f684..85ae794 100644
--- a/src/compiler_llvm/compiler_llvm.cc
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -126,7 +126,7 @@
 
 
 CompilationUnit* CompilerLLVM::AllocateCompilationUnit() {
-  MutexLock GUARD(num_cunits_lock_);
+  MutexLock GUARD(Thread::Current(), num_cunits_lock_);
   CompilationUnit* cunit = new CompilationUnit(this, num_cunits_++);
   if (!bitcode_filename_.empty()) {
     cunit->SetBitcodeFileName(StringPrintf("%s-%zu", bitcode_filename_.c_str(), num_cunits_-1));
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index 3bb4ae5..d7e146a 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -230,17 +230,17 @@
 Object* art_alloc_array_from_code(uint32_t type_idx,
                                   AbstractMethod* referrer,
                                   uint32_t length,
-                                  Thread* /*thread*/)
+                                  Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  return AllocArrayFromCode(type_idx, referrer, length, false);
+  return AllocArrayFromCode(type_idx, referrer, length, self, false);
 }
 
 Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
                                                     AbstractMethod* referrer,
                                                     uint32_t length,
-                                                    Thread* /*thread*/)
+                                                    Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  return AllocArrayFromCode(type_idx, referrer, length, true);
+  return AllocArrayFromCode(type_idx, referrer, length, self, true);
 }
 
 Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
@@ -748,12 +748,12 @@
   va_start(ap, proxy_method);
 
   Object* receiver = va_arg(ap, Object*);
-  Thread* thread = va_arg(ap, Thread*);
+  Thread* self = va_arg(ap, Thread*);
   MethodHelper proxy_mh(proxy_method);
   const size_t num_params = proxy_mh.NumArgs();
 
   // Start new JNI local reference state
-  JNIEnvExt* env = thread->GetJniEnv();
+  JNIEnvExt* env = self->GetJniEnv();
   ScopedObjectAccessUnchecked soa(env);
   ScopedJniEnvLocalRefState env_state(env);
 
@@ -773,9 +773,9 @@
   args_jobj[2].l = NULL;
   ObjectArray<Object>* args = NULL;
   if ((num_params - 1) > 0) {
-    args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(num_params - 1);
+    args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(self, num_params - 1);
     if (args == NULL) {
-      CHECK(thread->IsExceptionPending());
+      CHECK(self->IsExceptionPending());
       return;
     }
     args_jobj[2].l = soa.AddLocalReference<jobjectArray>(args);
@@ -783,9 +783,9 @@
 
   // Get parameter types.
   const char* shorty = proxy_mh.GetShorty();
-  ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes();
+  ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes(self);
   if (param_types == NULL) {
-    CHECK(thread->IsExceptionPending());
+    CHECK(self->IsExceptionPending());
     return;
   }
 
@@ -822,7 +822,7 @@
     Class* param_type = param_types->Get(i);
     if (param_type->IsPrimitive()) {
       BoxPrimitive(param_type->GetPrimitiveType(), val);
-      if (thread->IsExceptionPending()) {
+      if (self->IsExceptionPending()) {
         return;
       }
     }
@@ -836,19 +836,19 @@
   jobject result = env->CallObjectMethodA(inv_hand, WellKnownClasses::java_lang_reflect_InvocationHandler_invoke, args_jobj);
 
   // Place result in stack args
-  if (!thread->IsExceptionPending()) {
+  if (!self->IsExceptionPending()) {
     if (shorty[0] == 'V') {
       return;
     }
-    Object* result_ref = thread->DecodeJObject(result);
+    Object* result_ref = self->DecodeJObject(result);
     JValue* result_unboxed = va_arg(ap, JValue*);
     if (result_ref == NULL) {
       result_unboxed->SetL(NULL);
     } else {
       bool unboxed_okay = UnboxPrimitiveForResult(result_ref, proxy_mh.GetReturnType(), *result_unboxed);
       if (!unboxed_okay) {
-        thread->ClearException();
-        thread->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
+        self->ClearException();
+        self->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
                                  "Couldn't convert result of type %s to %s",
                                  PrettyTypeOf(result_ref).c_str(),
                                  PrettyDescriptor(proxy_mh.GetReturnType()).c_str());
@@ -858,7 +858,7 @@
   } else {
     // In the case of checked exceptions that aren't declared, the exception must be wrapped by
     // a UndeclaredThrowableException.
-    Throwable* exception = thread->GetException();
+    Throwable* exception = self->GetException();
     if (exception->IsCheckedException()) {
       SynthesizedProxyClass* proxy_class =
           down_cast<SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
@@ -879,7 +879,7 @@
         declares_exception = declared_exception->IsAssignableFrom(exception_class);
       }
       if (!declares_exception) {
-        thread->ThrowNewWrappedException("Ljava/lang/reflect/UndeclaredThrowableException;", NULL);
+        self->ThrowNewWrappedException("Ljava/lang/reflect/UndeclaredThrowableException;", NULL);
       }
     }
   }
diff --git a/src/debugger.cc b/src/debugger.cc
index e28845f..c8e7381 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -55,19 +55,19 @@
       return 0;
     }
     JDWP::ObjectId id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(o));
-    MutexLock mu(lock_);
+    MutexLock mu(Thread::Current(), lock_);
     map_.Overwrite(id, o);
     return id;
   }
 
   void Clear() {
-    MutexLock mu(lock_);
+    MutexLock mu(Thread::Current(), lock_);
     LOG(DEBUG) << "Debugger has detached; object registry had " << map_.size() << " entries";
     map_.clear();
   }
 
   bool Contains(JDWP::ObjectId id) {
-    MutexLock mu(lock_);
+    MutexLock mu(Thread::Current(), lock_);
     return map_.find(id) != map_.end();
   }
 
@@ -76,14 +76,14 @@
       return NULL;
     }
 
-    MutexLock mu(lock_);
+    MutexLock mu(Thread::Current(), lock_);
     typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
     It it = map_.find(id);
     return (it != map_.end()) ? reinterpret_cast<T>(it->second) : reinterpret_cast<T>(kInvalidId);
   }
 
   void VisitRoots(Heap::RootVisitor* visitor, void* arg) {
-    MutexLock mu(lock_);
+    MutexLock mu(Thread::Current(), lock_);
     typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
     for (It it = map_.begin(); it != map_.end(); ++it) {
       visitor(it->second, arg);
@@ -184,7 +184,7 @@
 
 static bool IsBreakpoint(AbstractMethod* m, uint32_t dex_pc)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(Thread::Current(), gBreakpointsLock);
   for (size_t i = 0; i < gBreakpoints.size(); ++i) {
     if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == dex_pc) {
       VLOG(jdwp) << "Hit breakpoint #" << i << ": " << gBreakpoints[i];
@@ -492,7 +492,7 @@
 }
 
 static void SetDebuggerUpdatesEnabled(bool enabled) {
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(SetDebuggerUpdatesEnabledCallback, &enabled);
 }
 
@@ -508,7 +508,7 @@
 
   {
     // TODO: dalvik only warned if there were breakpoints left over. clear in Dbg::Disconnected?
-    MutexLock mu(gBreakpointsLock);
+    MutexLock mu(Thread::Current(), gBreakpointsLock);
     CHECK_EQ(gBreakpoints.size(), 0U);
   }
 
@@ -884,7 +884,7 @@
 }
 
 JDWP::ObjectId Dbg::CreateString(const std::string& str) {
-  return gRegistry->Add(String::AllocFromModifiedUtf8(str.c_str()));
+  return gRegistry->Add(String::AllocFromModifiedUtf8(Thread::Current(), str.c_str()));
 }
 
 JDWP::JdwpError Dbg::CreateObject(JDWP::RefTypeId classId, JDWP::ObjectId& new_object) {
@@ -893,7 +893,7 @@
   if (c == NULL) {
     return status;
   }
-  new_object = gRegistry->Add(c->AllocObject());
+  new_object = gRegistry->Add(c->AllocObject(Thread::Current()));
   return JDWP::ERR_NONE;
 }
 
@@ -907,7 +907,7 @@
   if (c == NULL) {
     return status;
   }
-  new_array = gRegistry->Add(Array::Alloc(c, length));
+  new_array = gRegistry->Add(Array::Alloc(Thread::Current(), c, length));
   return JDWP::ERR_NONE;
 }
 
@@ -1331,8 +1331,9 @@
 }
 
 bool Dbg::GetThreadName(JDWP::ObjectId threadId, std::string& name) {
-  MutexLock mu(*Locks::thread_list_lock_);
-  ScopedObjectAccessUnchecked soa(Thread::Current());
+  Thread* self = Thread::Current();
+  MutexLock mu(self, *Locks::thread_list_lock_);
+  ScopedObjectAccessUnchecked soa(self);
   Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return false;
@@ -1349,7 +1350,7 @@
   }
 
   // Okay, so it's an object, but is it actually a thread?
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   if (DecodeThread(soa, threadId) == NULL) {
     return JDWP::ERR_INVALID_THREAD;
   }
@@ -1408,13 +1409,13 @@
 bool Dbg::GetThreadStatus(JDWP::ObjectId threadId, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus) {
   ScopedObjectAccess soa(Thread::Current());
 
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return false;
   }
 
-  MutexLock mu2(*Locks::thread_suspend_count_lock_);
+  MutexLock mu2(soa.Self(), *Locks::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).
@@ -1448,28 +1449,28 @@
 JDWP::JdwpError Dbg::GetThreadDebugSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
   ScopedObjectAccess soa(Thread::Current());
 
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = DecodeThread(soa, threadId);
   if (thread == NULL) {
     return JDWP::ERR_INVALID_THREAD;
   }
-  MutexLock mu2(*Locks::thread_suspend_count_lock_);
+  MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
   expandBufAdd4BE(pReply, thread->GetDebugSuspendCount());
   return JDWP::ERR_NONE;
 }
 
 bool Dbg::ThreadExists(JDWP::ObjectId threadId) {
   ScopedObjectAccess soa(Thread::Current());
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   return DecodeThread(soa, threadId) != NULL;
 }
 
 bool Dbg::IsSuspended(JDWP::ObjectId threadId) {
   ScopedObjectAccess soa(Thread::Current());
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = DecodeThread(soa, threadId);
   CHECK(thread != NULL);
-  MutexLock mu2(*Locks::thread_suspend_count_lock_);
+  MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
   return thread->IsSuspended();
 }
 
@@ -1513,7 +1514,7 @@
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
   ThreadListVisitor tlv(soa, thread_group, thread_ids);
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Runtime::Current()->GetThreadList()->ForEach(ThreadListVisitor::Visit, &tlv);
 }
 
@@ -1554,7 +1555,7 @@
   };
 
   if (kIsDebugBuild) {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
+    MutexLock mu(Thread::Current(), *Locks::thread_suspend_count_lock_);
     CHECK(thread->IsSuspended());
   }
   CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
@@ -1652,7 +1653,7 @@
 void Dbg::ResumeThread(JDWP::ObjectId threadId) {
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Object* peer = gRegistry->Get<Object*>(threadId);
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = Thread::FromManagedThread(soa, peer);
   if (thread == NULL) {
     LOG(WARNING) << "No such thread for resume: " << peer;
@@ -1660,7 +1661,7 @@
   }
   bool needs_resume;
   {
-    MutexLock mu2(*Locks::thread_suspend_count_lock_);
+    MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
     needs_resume = thread->GetSuspendCount() > 0;
   }
   if (needs_resume) {
@@ -1716,12 +1717,12 @@
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Thread* thread;
   {
-    MutexLock mu(*Locks::thread_list_lock_);
+    MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
     thread = DecodeThread(soa, thread_id);
     if (thread == NULL) {
       return JDWP::ERR_INVALID_THREAD;
     }
-    MutexLock mu2(*Locks::thread_suspend_count_lock_);
+    MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
     if (!thread->IsSuspended()) {
       return JDWP::ERR_THREAD_NOT_SUSPENDED;
     }
@@ -2020,7 +2021,7 @@
 
   // If the debugger is single-stepping one of our threads, check to
   // see if we're that thread and we've reached a step point.
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(Thread::Current(), gBreakpointsLock);
   if (gSingleStepControl.is_active && gSingleStepControl.thread == self) {
     CHECK(!m->IsNative());
     if (gSingleStepControl.step_depth == JDWP::SD_INTO) {
@@ -2104,14 +2105,14 @@
 }
 
 void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(Thread::Current(), gBreakpointsLock);
   AbstractMethod* m = FromMethodId(location->method_id);
   gBreakpoints.push_back(Breakpoint(m, location->dex_pc));
   VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": " << gBreakpoints[gBreakpoints.size() - 1];
 }
 
 void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location) {
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(Thread::Current(), gBreakpointsLock);
   AbstractMethod* m = FromMethodId(location->method_id);
   for (size_t i = 0; i < gBreakpoints.size(); ++i) {
     if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == location->dex_pc) {
@@ -2130,7 +2131,7 @@
     return JDWP::ERR_INVALID_THREAD;
   }
 
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(soa.Self(), 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) {
@@ -2149,7 +2150,7 @@
         EXCLUSIVE_LOCKS_REQUIRED(gBreakpointsLock)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
         : StackVisitor(stack, trace_stack, NULL) {
-      gBreakpointsLock.AssertHeld();
+      gBreakpointsLock.AssertHeld(Thread::Current());
       gSingleStepControl.method = NULL;
       gSingleStepControl.stack_depth = 0;
     }
@@ -2157,7 +2158,7 @@
     // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
     // annotalysis.
     bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
-      gBreakpointsLock.AssertHeld();
+      gBreakpointsLock.AssertHeld(Thread::Current());
       const AbstractMethod* m = GetMethod();
       if (!m->IsRuntimeMethod()) {
         ++gSingleStepControl.stack_depth;
@@ -2188,7 +2189,7 @@
     }
 
     static bool Callback(void* raw_context, uint32_t address, uint32_t line_number) {
-      MutexLock mu(gBreakpointsLock); // Keep GCC happy.
+      MutexLock mu(Thread::Current(), gBreakpointsLock); // Keep GCC happy.
       DebugCallbackContext* context = reinterpret_cast<DebugCallbackContext*>(raw_context);
       if (static_cast<int32_t>(line_number) == gSingleStepControl.line_number) {
         if (!context->last_pc_valid) {
@@ -2209,7 +2210,7 @@
     }
 
     ~DebugCallbackContext() {
-      MutexLock mu(gBreakpointsLock); // Keep GCC happy.
+      MutexLock mu(Thread::Current(), gBreakpointsLock); // Keep GCC happy.
       // If the line number was the last in the position table...
       if (last_pc_valid) {
         size_t end = MethodHelper(gSingleStepControl.method).GetCodeItem()->insns_size_in_code_units_;
@@ -2259,7 +2260,7 @@
 }
 
 void Dbg::UnconfigureStep(JDWP::ObjectId /*threadId*/) {
-  MutexLock mu(gBreakpointsLock);
+  MutexLock mu(Thread::Current(), gBreakpointsLock);
 
   gSingleStepControl.is_active = false;
   gSingleStepControl.thread = NULL;
@@ -2307,7 +2308,7 @@
   Thread* self = Thread::Current();
   {
     ScopedObjectAccessUnchecked soa(self);
-    MutexLock mu(*Locks::thread_list_lock_);
+    MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
     targetThread = DecodeThread(soa, threadId);
     if (targetThread == NULL) {
       LOG(ERROR) << "InvokeMethod request for non-existent thread " << threadId;
@@ -2335,7 +2336,7 @@
      */
     int suspend_count;
     {
-      MutexLock mu2(*Locks::thread_suspend_count_lock_);
+      MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
       suspend_count = targetThread->GetSuspendCount();
     }
     if (suspend_count > 1) {
@@ -2411,7 +2412,7 @@
 
     VLOG(jdwp) << "    Transferring control to event thread";
     {
-      MutexLock mu(req->lock_);
+      MutexLock mu(self, req->lock_);
 
       if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
         VLOG(jdwp) << "      Resuming all threads";
@@ -2631,12 +2632,9 @@
   VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
 
   Thread* self = Thread::Current();
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    if (self->GetState() != kRunnable) {
-      LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
-      /* try anyway? */
-    }
+  if (self->GetState() != kRunnable) {
+    LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
+    /* try anyway? */
   }
 
   JNIEnv* env = self->GetJniEnv();
@@ -2699,12 +2697,13 @@
     // notification.
     SuspendVM();
     std::list<Thread*> threads;
+    Thread* self = Thread::Current();
     {
-      MutexLock mu(*Locks::thread_list_lock_);
+      MutexLock mu(self, *Locks::thread_list_lock_);
       threads = Runtime::Current()->GetThreadList()->GetList();
     }
     {
-      ScopedObjectAccess soa(Thread::Current());
+      ScopedObjectAccess soa(self);
       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"));
@@ -3096,9 +3095,10 @@
   } else {
     Heap* heap = Runtime::Current()->GetHeap();
     const Spaces& spaces = heap->GetSpaces();
+    Thread* self = Thread::Current();
     for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) {
       if ((*cur)->IsAllocSpace()) {
-        ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+        ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
         (*cur)->AsAllocSpace()->Walk(HeapChunkContext::HeapChunkCallback, &context);
       }
     }
@@ -3111,7 +3111,7 @@
 }
 
 void Dbg::SetAllocTrackingEnabled(bool enabled) {
-  MutexLock mu(gAllocTrackerLock);
+  MutexLock mu(Thread::Current(), gAllocTrackerLock);
   if (enabled) {
     if (recent_allocation_records_ == NULL) {
       LOG(INFO) << "Enabling alloc tracker (" << kNumAllocRecords << " entries, "
@@ -3164,7 +3164,7 @@
   Thread* self = Thread::Current();
   CHECK(self != NULL);
 
-  MutexLock mu(gAllocTrackerLock);
+  MutexLock mu(self, gAllocTrackerLock);
   if (recent_allocation_records_ == NULL) {
     return;
   }
@@ -3203,7 +3203,7 @@
 
 void Dbg::DumpRecentAllocations() {
   ScopedObjectAccess soa(Thread::Current());
-  MutexLock mu(gAllocTrackerLock);
+  MutexLock mu(soa.Self(), gAllocTrackerLock);
   if (recent_allocation_records_ == NULL) {
     LOG(INFO) << "Not recording tracked allocations";
     return;
@@ -3323,7 +3323,8 @@
     DumpRecentAllocations();
   }
 
-  MutexLock mu(gAllocTrackerLock);
+  Thread* self = Thread::Current();
+  MutexLock mu(self, gAllocTrackerLock);
 
   //
   // Part 1: generate string tables.
@@ -3428,7 +3429,7 @@
   method_names.WriteTo(bytes);
   filenames.WriteTo(bytes);
 
-  JNIEnv* env = Thread::Current()->GetJniEnv();
+  JNIEnv* env = self->GetJniEnv();
   jbyteArray result = env->NewByteArray(bytes.size());
   if (result != NULL) {
     env->SetByteArrayRegion(result, 0, bytes.size(), reinterpret_cast<const jbyte*>(&bytes[0]));
diff --git a/src/dex_cache_test.cc b/src/dex_cache_test.cc
index 6c0107c..b131e4c 100644
--- a/src/dex_cache_test.cc
+++ b/src/dex_cache_test.cc
@@ -29,7 +29,8 @@
 
 TEST_F(DexCacheTest, Open) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<DexCache> dex_cache(soa.Self(), class_linker_->AllocDexCache(*java_lang_dex_file_));
+  SirtRef<DexCache> dex_cache(soa.Self(), class_linker_->AllocDexCache(soa.Self(),
+                                                                       *java_lang_dex_file_));
   ASSERT_TRUE(dex_cache.get() != NULL);
 
   EXPECT_EQ(java_lang_dex_file_->NumStringIds(), dex_cache->NumStrings());
diff --git a/src/heap.cc b/src/heap.cc
index fa044c2..f7cb68d 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -277,7 +277,7 @@
 };
 
 void Heap::AddSpace(ContinuousSpace* space) {
-  WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+  WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   DCHECK(space != NULL);
   DCHECK(space->GetLiveBitmap() != NULL);
   live_bitmap_->AddSpaceBitmap(space->GetLiveBitmap());
@@ -357,7 +357,7 @@
   }
 }
 
-Object* Heap::AllocObject(Class* c, size_t byte_count) {
+Object* Heap::AllocObject(Thread* self, Class* c, size_t byte_count) {
   DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(Class)) ||
          (c->IsVariableSize() || c->GetObjectSize() == byte_count) ||
          strlen(ClassHelper(c).GetDescriptor()) == 0);
@@ -372,7 +372,7 @@
   // range. This also means that we rely on SetClass not dirtying the object's card.
   if (byte_count >= large_object_threshold_ && have_zygote_space_ && c->IsPrimitiveArray()) {
     size = RoundUp(byte_count, kPageSize);
-    obj = Allocate(NULL, size);
+    obj = Allocate(self, NULL, size);
 
     if (obj != NULL) {
       // Make sure that our large object didn't get placed anywhere within the space interval or else
@@ -381,7 +381,7 @@
              reinterpret_cast<byte*>(obj) >= spaces_.back()->End());
     }
   } else {
-    obj = Allocate(alloc_space_, byte_count);
+    obj = Allocate(self, alloc_space_, byte_count);
     size = alloc_space_->AllocationSize(obj);
 
     if (obj != NULL) {
@@ -405,7 +405,6 @@
       // concurrent_start_bytes_.
       concurrent_start_bytes_ = std::numeric_limits<size_t>::max();
       // The SirtRef is necessary since the calls in RequestConcurrentGC are a safepoint.
-      Thread* self = Thread::Current();
       SirtRef<Object> ref(self, obj);
       RequestConcurrentGC(self);
     }
@@ -424,7 +423,7 @@
 
   std::string msg(StringPrintf("Failed to allocate a %zd-byte %s (%lld total bytes free; largest possible contiguous allocation %zd bytes)",
                                byte_count, PrettyDescriptor(c).c_str(), total_bytes_free, max_contiguous_allocation));
-  Thread::Current()->ThrowOutOfMemoryError(msg.c_str());
+  self->ThrowOutOfMemoryError(msg.c_str());
   return NULL;
 }
 
@@ -483,7 +482,7 @@
     if (!std::binary_search(live_stack_->Begin(), live_stack_->End(), obj) &&
         std::find(allocation_stack_->Begin(), allocation_stack_->End(), obj) ==
             allocation_stack_->End()) {
-      ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+      ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
       if (large_object_space_->GetLiveObjects()->Test(obj)) {
         DumpSpaces();
         LOG(FATAL) << "Object is dead: " << obj;
@@ -520,7 +519,7 @@
 }
 
 void Heap::VerifyHeap() {
-  ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+  ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   GetLiveBitmap()->Walk(Heap::VerificationCallback, this);
 }
 
@@ -561,44 +560,38 @@
   }
 }
 
-Object* Heap::TryToAllocate(AllocSpace* space, size_t alloc_size, bool grow) {
+Object* Heap::TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow) {
   // Should we try to use a CAS here and fix up num_bytes_allocated_ later with AllocationSize?
   if (num_bytes_allocated_ + alloc_size > growth_limit_) {
     return NULL;
   }
 
   if (UNLIKELY(space == NULL)) {
-    return large_object_space_->Alloc(alloc_size);
+    return large_object_space_->Alloc(self, alloc_size);
   } else if (grow) {
-    return space->AllocWithGrowth(alloc_size);
+    return space->AllocWithGrowth(self, alloc_size);
   } else {
-    return space->AllocWithoutGrowth(alloc_size);
+    return space->AllocWithoutGrowth(self, alloc_size);
   }
 }
 
-Object* Heap::Allocate(AllocSpace* space, size_t alloc_size) {
+Object* Heap::Allocate(Thread* self, AllocSpace* space, size_t alloc_size) {
   // 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.
-#ifndef NDEBUG
-  Thread* self = Thread::Current();
   DCHECK_EQ(self->GetState(), kRunnable);
   self->AssertThreadSuspensionIsAllowable();
-#endif
 
-  Object* ptr = TryToAllocate(space, alloc_size, false);
+  Object* ptr = TryToAllocate(self, space, alloc_size, false);
   if (ptr != NULL) {
     return ptr;
   }
 
   // The allocation failed. If the GC is running, block until it completes, and then retry the
   // allocation.
-#ifdef NDEBUG
-  Thread* self = Thread::Current();
-#endif
   GcType last_gc = WaitForConcurrentGcToComplete(self);
   if (last_gc != kGcTypeNone) {
     // A GC was in progress and we blocked, retry allocation now that memory has been freed.
-    ptr = TryToAllocate(space, alloc_size, false);
+    ptr = TryToAllocate(self, space, alloc_size, false);
     if (ptr != NULL) {
       return ptr;
     }
@@ -635,7 +628,7 @@
       self->TransitionFromSuspendedToRunnable();
 
       // Did we free sufficient memory for the allocation to succeed?
-      ptr = TryToAllocate(space, alloc_size, false);
+      ptr = TryToAllocate(self, space, alloc_size, false);
       if (ptr != NULL) {
         return ptr;
       }
@@ -644,7 +637,7 @@
 
   // Allocations have failed after GCs;  this is an exceptional state.
   // Try harder, growing the heap if necessary.
-  ptr = TryToAllocate(space, alloc_size, true);
+  ptr = TryToAllocate(self, space, alloc_size, true);
   if (ptr != NULL) {
     if (space != NULL) {
       size_t new_footprint = space->GetFootprintLimit();
@@ -669,7 +662,7 @@
   self->TransitionFromRunnableToSuspended(kWaitingPerformingGc);
   CollectGarbageInternal(kGcTypeFull, kGcCauseForAlloc, true);
   self->TransitionFromSuspendedToRunnable();
-  return TryToAllocate(space, alloc_size, true);
+  return TryToAllocate(self, space, alloc_size, true);
 }
 
 int64_t Heap::GetMaxMemory() {
@@ -721,7 +714,7 @@
 };
 
 int64_t Heap::CountInstances(Class* c, bool count_assignable) {
-  ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+  ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   InstanceCounter counter(c, count_assignable);
   GetLiveBitmap()->Walk(InstanceCounter::Callback, &counter);
   return counter.GetCount();
@@ -1620,12 +1613,12 @@
     {
       // TODO: this lock shouldn't be necessary (it's why we did the bitmap flip above).
       if (gc_type != kGcTypeSticky) {
-        WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+        WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
         mark_sweep.SweepLargeObjects(swap);
         timings.AddSplit("SweepLargeObjects");
         mark_sweep.Sweep(gc_type == kGcTypePartial, swap);
       } else {
-        WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+        WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
         mark_sweep.SweepArray(timings, live_stack_.get(), swap);
         timings.AddSplit("SweepArray");
       }
diff --git a/src/heap.h b/src/heap.h
index 5fe491f..7a96fd6 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -77,7 +77,7 @@
 };
 std::ostream& operator<<(std::ostream& os, const GcCause& policy);
 
-class LOCKABLE Heap {
+class Heap {
  public:
   static const size_t kInitialSize = 2 * MB;
 
@@ -95,7 +95,7 @@
   ~Heap();
 
   // Allocates and initializes storage for an object instance.
-  Object* AllocObject(Class* klass, size_t num_bytes)
+  Object* AllocObject(Thread* self, Class* klass, size_t num_bytes)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Check sanity of given reference. Requires the heap lock.
@@ -296,12 +296,12 @@
  private:
   // Allocates uninitialized storage. Passing in a null space tries to place the object in the
   // large object space.
-  Object* Allocate(AllocSpace* space, size_t num_bytes)
+  Object* Allocate(Thread* self, AllocSpace* space, size_t num_bytes)
       LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   // Try to allocate a number of bytes, this function never does any GCs.
-  Object* TryToAllocate(AllocSpace* space, size_t alloc_size, bool grow)
+  Object* TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow)
       LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/src/heap_test.cc b/src/heap_test.cc
index 881a765..6db7416 100644
--- a/src/heap_test.cc
+++ b/src/heap_test.cc
@@ -39,9 +39,10 @@
 
     Class* c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
     for (size_t i = 0; i < 1024; ++i) {
-      SirtRef<ObjectArray<Object> > array(soa.Self(), ObjectArray<Object>::Alloc(c, 2048));
+      SirtRef<ObjectArray<Object> > array(soa.Self(),
+                                          ObjectArray<Object>::Alloc(soa.Self(), c, 2048));
       for (size_t j = 0; j < 2048; ++j) {
-        array->Set(j, String::AllocFromModifiedUtf8("hello, world!"));
+        array->Set(j, String::AllocFromModifiedUtf8(soa.Self(), "hello, world!"));
       }
     }
   }
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index 0cad709..125b19a 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -407,12 +407,13 @@
     // Walk the roots and the heap.
     current_record_.StartNewRecord(body_fp_, HPROF_TAG_HEAP_DUMP_SEGMENT, HPROF_TIME);
     Runtime::Current()->VisitRoots(RootVisitor, this);
+    Thread* self = Thread::Current();
     {
-      WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+      WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
       Runtime::Current()->GetHeap()->FlushAllocStack();
     }
     {
-      ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+      ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
       Runtime::Current()->GetHeap()->GetLiveBitmap()->Walk(HeapBitmapCallback, this);
     }
     current_record_.StartNewRecord(body_fp_, HPROF_TAG_HEAP_DUMP_END, HPROF_TIME);
@@ -444,22 +445,27 @@
       if (fd_ >= 0) {
         out_fd = dup(fd_);
         if (out_fd < 0) {
-          Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;", "Couldn't dump heap; dup(%d) failed: %s", fd_, strerror(errno));
+          self->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
+                                   "Couldn't dump heap; dup(%d) failed: %s", fd_, strerror(errno));
           return;
         }
       } else {
         out_fd = open(filename_.c_str(), O_WRONLY|O_CREAT|O_TRUNC, 0644);
         if (out_fd < 0) {
-          Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;", "Couldn't dump heap; open(\"%s\") failed: %s", filename_.c_str(), strerror(errno));
+          self->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
+                                   "Couldn't dump heap; open(\"%s\") failed: %s", filename_.c_str(),
+                                   strerror(errno));
           return;
         }
       }
 
       UniquePtr<File> file(OS::FileFromFd(filename_.c_str(), out_fd));
-      okay = file->WriteFully(header_data_ptr_, header_data_size_) && file->WriteFully(body_data_ptr_, body_data_size_);
+      okay = file->WriteFully(header_data_ptr_, header_data_size_) &&
+          file->WriteFully(body_data_ptr_, body_data_size_);
       if (!okay) {
-        std::string msg(StringPrintf("Couldn't dump heap; writing \"%s\" failed: %s", filename_.c_str(), strerror(errno)));
-        Thread::Current()->ThrowNewException("Ljava/lang/RuntimeException;", msg.c_str());
+        std::string msg(StringPrintf("Couldn't dump heap; writing \"%s\" failed: %s",
+                                     filename_.c_str(), strerror(errno)));
+        self->ThrowNewException("Ljava/lang/RuntimeException;", msg.c_str());
         LOG(ERROR) << msg;
       }
       close(out_fd);
@@ -468,7 +474,9 @@
     // Throw out a log message for the benefit of "runhat".
     if (okay) {
       uint64_t duration = NanoTime() - start_ns_;
-      LOG(INFO) << "hprof: heap dump completed (" << PrettySize(header_data_size_ + body_data_size_ + 1023) << ") in " << PrettyDuration(duration);
+      LOG(INFO) << "hprof: heap dump completed ("
+          << PrettySize(header_data_size_ + body_data_size_ + 1023)
+          << ") in " << PrettyDuration(duration);
     }
   }
 
diff --git a/src/image_writer.cc b/src/image_writer.cc
index c876329..fe12baf 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -192,7 +192,7 @@
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // TODO: Check image spaces only?
   Heap* heap = Runtime::Current()->GetHeap();
-  ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+  ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
   heap->FlushAllocStack();
   heap->GetLiveBitmap()->Walk(ComputeEagerResolvedStringsCallback, this);
 }
@@ -276,12 +276,13 @@
   }
 
   Heap* heap = Runtime::Current()->GetHeap();
+  Thread* self = Thread::Current();
   {
-    WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+    WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
     heap->FlushAllocStack();
   }
 
-  ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+  ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
   heap->GetLiveBitmap()->Walk(CheckNonImageClassesRemovedCallback, this);
 }
 
@@ -340,9 +341,10 @@
   Runtime* runtime = Runtime::Current();
   ClassLinker* class_linker = runtime->GetClassLinker();
   Class* object_array_class = class_linker->FindSystemClass("[Ljava/lang/Object;");
+  Thread* self = Thread::Current();
 
   // build an Object[] of all the DexCaches used in the source_space_
-  ObjectArray<Object>* dex_caches = ObjectArray<Object>::Alloc(object_array_class,
+  ObjectArray<Object>* dex_caches = ObjectArray<Object>::Alloc(self, object_array_class,
                                                                dex_caches_.size());
   int i = 0;
   typedef Set::const_iterator It;  // TODO: C++0x auto
@@ -352,8 +354,9 @@
 
   // build an Object[] of the roots needed to restore the runtime
   SirtRef<ObjectArray<Object> >
-      image_roots(Thread::Current(),
-                  ObjectArray<Object>::Alloc(object_array_class, ImageHeader::kImageRootsMax));
+      image_roots(self,
+                  ObjectArray<Object>::Alloc(self, object_array_class,
+                                             ImageHeader::kImageRootsMax));
   image_roots->Set(ImageHeader::kJniStubArray, runtime->GetJniDlsymLookupStub());
   image_roots->Set(ImageHeader::kAbstractMethodErrorStubArray,
                    runtime->GetAbstractMethodErrorStubArray());
@@ -369,7 +372,7 @@
   image_roots->Set(ImageHeader::kRefsAndArgsSaveMethod,
                    runtime->GetCalleeSaveMethod(Runtime::kRefsAndArgs));
   image_roots->Set(ImageHeader::kOatLocation,
-                   String::AllocFromModifiedUtf8(oat_file_->GetLocation().c_str()));
+                   String::AllocFromModifiedUtf8(self, oat_file_->GetLocation().c_str()));
   image_roots->Set(ImageHeader::kDexCaches,
                    dex_caches);
   image_roots->Set(ImageHeader::kClassRoots,
@@ -425,15 +428,16 @@
 
 void ImageWriter::CopyAndFixupObjects()
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  const char* old_cause = Thread::Current()->StartAssertNoThreadSuspension("ImageWriter");
+  Thread* self = Thread::Current();
+  const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter");
   Heap* heap = Runtime::Current()->GetHeap();
   // TODO: heap validation can't handle this fix up pass
   heap->DisableObjectValidation();
   // TODO: Image spaces only?
-  ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+  ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
   heap->FlushAllocStack();
   heap->GetLiveBitmap()->Walk(CopyAndFixupObjectsCallback, this);
-  Thread::Current()->EndAssertNoThreadSuspension(old_cause);
+  self->EndAssertNoThreadSuspension(old_cause);
 }
 
 void ImageWriter::CopyAndFixupObjectsCallback(Object* object, void* arg) {
diff --git a/src/indirect_reference_table_test.cc b/src/indirect_reference_table_test.cc
index 971e42a..b5a05ec 100644
--- a/src/indirect_reference_table_test.cc
+++ b/src/indirect_reference_table_test.cc
@@ -49,13 +49,13 @@
 
   Class* c = class_linker_->FindSystemClass("Ljava/lang/Object;");
   ASSERT_TRUE(c != NULL);
-  Object* obj0 = c->AllocObject();
+  Object* obj0 = c->AllocObject(soa.Self());
   ASSERT_TRUE(obj0 != NULL);
-  Object* obj1 = c->AllocObject();
+  Object* obj1 = c->AllocObject(soa.Self());
   ASSERT_TRUE(obj1 != NULL);
-  Object* obj2 = c->AllocObject();
+  Object* obj2 = c->AllocObject(soa.Self());
   ASSERT_TRUE(obj2 != NULL);
-  Object* obj3 = c->AllocObject();
+  Object* obj3 = c->AllocObject(soa.Self());
   ASSERT_TRUE(obj3 != NULL);
 
   const uint32_t cookie = IRT_FIRST_SEGMENT;
diff --git a/src/intern_table.cc b/src/intern_table.cc
index 10dd7f0..5ad3958 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -25,19 +25,19 @@
 }
 
 size_t InternTable::Size() const {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   return strong_interns_.size() + weak_interns_.size();
 }
 
 void InternTable::DumpForSigQuit(std::ostream& os) const {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   os << "Intern table: " << strong_interns_.size() << " strong; "
      << weak_interns_.size() << " weak; "
      << image_strong_interns_.size() << " image strong\n";
 }
 
 void InternTable::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   typedef Table::const_iterator It; // TODO: C++0x auto
   for (It it = strong_interns_.begin(), end = strong_interns_.end(); it != end; ++it) {
     visitor(it->second, arg);
@@ -46,7 +46,7 @@
 }
 
 String* InternTable::Lookup(Table& table, String* s, uint32_t hash_code) {
-  intern_table_lock_.AssertHeld();
+  intern_table_lock_.AssertHeld(Thread::Current());
   typedef Table::const_iterator It; // TODO: C++0x auto
   for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
     String* existing_string = it->second;
@@ -58,18 +58,18 @@
 }
 
 String* InternTable::Insert(Table& table, String* s, uint32_t hash_code) {
-  intern_table_lock_.AssertHeld();
+  intern_table_lock_.AssertHeld(Thread::Current());
   table.insert(std::make_pair(hash_code, s));
   return s;
 }
 
 void InternTable::RegisterStrong(String* s) {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   Insert(image_strong_interns_, s, s->GetHashCode());
 }
 
 void InternTable::Remove(Table& table, const String* s, uint32_t hash_code) {
-  intern_table_lock_.AssertHeld();
+  intern_table_lock_.AssertHeld(Thread::Current());
   typedef Table::iterator It; // TODO: C++0x auto
   for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
     if (it->second == s) {
@@ -80,7 +80,7 @@
 }
 
 String* InternTable::Insert(String* s, bool is_strong) {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
 
   DCHECK(s != NULL);
   uint32_t hash_code = s->GetHashCode();
@@ -129,11 +129,11 @@
 }
 
 String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
-  return InternStrong(String::AllocFromModifiedUtf8(utf16_length, utf8_data));
+  return InternStrong(String::AllocFromModifiedUtf8(Thread::Current(), utf16_length, utf8_data));
 }
 
 String* InternTable::InternStrong(const char* utf8_data) {
-  return InternStrong(String::AllocFromModifiedUtf8(utf8_data));
+  return InternStrong(String::AllocFromModifiedUtf8(Thread::Current(), utf8_data));
 }
 
 String* InternTable::InternStrong(String* s) {
@@ -151,13 +151,13 @@
 }
 
 bool InternTable::ContainsWeak(String* s) {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   const String* found = Lookup(weak_interns_, s, s->GetHashCode());
   return found == s;
 }
 
 void InternTable::SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg) {
-  MutexLock mu(intern_table_lock_);
+  MutexLock mu(Thread::Current(), intern_table_lock_);
   typedef Table::iterator It; // TODO: C++0x auto
   for (It it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
     Object* object = it->second;
diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index 2833f6e..ee9165e 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -29,7 +29,7 @@
   InternTable intern_table;
   SirtRef<String> foo_1(soa.Self(), intern_table.InternStrong(3, "foo"));
   SirtRef<String> foo_2(soa.Self(), intern_table.InternStrong(3, "foo"));
-  SirtRef<String> foo_3(soa.Self(), String::AllocFromModifiedUtf8("foo"));
+  SirtRef<String> foo_3(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
   SirtRef<String> bar(soa.Self(), intern_table.InternStrong(3, "bar"));
   EXPECT_TRUE(foo_1->Equals("foo"));
   EXPECT_TRUE(foo_2->Equals("foo"));
@@ -47,7 +47,7 @@
   InternTable t;
   EXPECT_EQ(0U, t.Size());
   t.InternStrong(3, "foo");
-  SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8("foo"));
+  SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
   t.InternWeak(foo.get());
   EXPECT_EQ(1U, t.Size());
   t.InternStrong(3, "bar");
@@ -91,8 +91,8 @@
   InternTable t;
   t.InternStrong(3, "foo");
   t.InternStrong(3, "bar");
-  SirtRef<String> hello(soa.Self(), String::AllocFromModifiedUtf8("hello"));
-  SirtRef<String> world(soa.Self(), String::AllocFromModifiedUtf8("world"));
+  SirtRef<String> hello(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "hello"));
+  SirtRef<String> world(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "world"));
   SirtRef<String> s0(soa.Self(), t.InternWeak(hello.get()));
   SirtRef<String> s1(soa.Self(), t.InternWeak(world.get()));
 
@@ -110,7 +110,7 @@
   EXPECT_EQ(2U, t.Size());
 
   // Just check that we didn't corrupt the map.
-  SirtRef<String> still_here(soa.Self(), String::AllocFromModifiedUtf8("still here"));
+  SirtRef<String> still_here(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "still here"));
   t.InternWeak(still_here.get());
   EXPECT_EQ(3U, t.Size());
 }
@@ -130,8 +130,8 @@
   {
     // Weaks are always weak.
     InternTable t;
-    SirtRef<String> foo_1(soa.Self(), String::AllocFromModifiedUtf8("foo"));
-    SirtRef<String> foo_2(soa.Self(), String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> foo_1(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+    SirtRef<String> foo_2(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
     EXPECT_NE(foo_1.get(), foo_2.get());
     SirtRef<String> interned_foo_1(soa.Self(), t.InternWeak(foo_1.get()));
     SirtRef<String> interned_foo_2(soa.Self(), t.InternWeak(foo_2.get()));
@@ -142,7 +142,7 @@
   {
     // A weak can be promoted to a strong.
     InternTable t;
-    SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
     SirtRef<String> interned_foo_1(soa.Self(), t.InternWeak(foo.get()));
     EXPECT_TRUE(t.ContainsWeak(interned_foo_1.get()));
     SirtRef<String> interned_foo_2(soa.Self(), t.InternStrong(3, "foo"));
@@ -155,7 +155,7 @@
     InternTable t;
     SirtRef<String> interned_foo_1(soa.Self(), t.InternStrong(3, "foo"));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_1.get()));
-    SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8("foo"));
+    SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
     SirtRef<String> interned_foo_2(soa.Self(), t.InternWeak(foo.get()));
     EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
     EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
diff --git a/src/jdwp/jdwp_event.cc b/src/jdwp/jdwp_event.cc
index 19f10eb..2865f3a 100644
--- a/src/jdwp/jdwp_event.cc
+++ b/src/jdwp/jdwp_event.cc
@@ -141,7 +141,7 @@
  * not be added to the list, and an appropriate error will be returned.
  */
 JdwpError JdwpState::RegisterEvent(JdwpEvent* pEvent) {
-  MutexLock mu(event_list_lock_);
+  MutexLock mu(Thread::Current(), event_list_lock_);
 
   CHECK(pEvent != NULL);
   CHECK(pEvent->prev == NULL);
@@ -234,7 +234,7 @@
  * explicitly remove one-off single-step events.)
  */
 void JdwpState::UnregisterEventById(uint32_t requestId) {
-  MutexLock mu(event_list_lock_);
+  MutexLock mu(Thread::Current(), event_list_lock_);
 
   JdwpEvent* pEvent = event_list_;
   while (pEvent != NULL) {
@@ -254,7 +254,7 @@
  * Remove all entries from the event list.
  */
 void JdwpState::UnregisterAll() {
-  MutexLock mu(event_list_lock_);
+  MutexLock mu(Thread::Current(), event_list_lock_);
 
   JdwpEvent* pEvent = event_list_;
   while (pEvent != NULL) {
@@ -537,7 +537,7 @@
     pReq->invoke_needed_ = false;
 
     VLOG(jdwp) << "invoke complete, signaling and self-suspending";
-    MutexLock mu(pReq->lock_);
+    MutexLock mu(Thread::Current(), pReq->lock_);
     pReq->cond_.Signal();
   }
 }
@@ -615,7 +615,7 @@
    * function is called by dvmSuspendSelf(), and the transition back
    * to RUNNING would confuse it.
    */
-  MutexLock mu(event_thread_lock_);
+  MutexLock mu(Thread::Current(), event_thread_lock_);
 
   CHECK_NE(event_thread_id_, 0U);
   VLOG(jdwp) << StringPrintf("cleared event token (%#llx)", event_thread_id_);
@@ -676,7 +676,7 @@
 
   ExpandBuf* pReq = eventPrep();
   {
-    MutexLock mu(event_list_lock_); // probably don't need this here
+    MutexLock mu(Thread::Current(), event_list_lock_); // probably don't need this here
 
     VLOG(jdwp) << "EVENT: " << EK_VM_START;
     VLOG(jdwp) << "  suspend_policy=" << suspend_policy;
@@ -757,7 +757,7 @@
   JdwpSuspendPolicy suspend_policy = SP_NONE;
 
   {
-    MutexLock mu(event_list_lock_);
+    MutexLock mu(Thread::Current(), event_list_lock_);
     match_list = AllocMatchList(event_list_size_);
     if ((eventFlags & Dbg::kBreakpoint) != 0) {
       FindMatchingEvents(EK_BREAKPOINT, &basket, match_list, &match_count);
@@ -828,7 +828,7 @@
   int match_count = 0;
   {
     // Don't allow the list to be updated while we scan it.
-    MutexLock mu(event_list_lock_);
+    MutexLock mu(Thread::Current(), event_list_lock_);
     JdwpEvent** match_list = AllocMatchList(event_list_size_);
 
     if (start) {
@@ -917,7 +917,7 @@
   ExpandBuf* pReq = NULL;
   JdwpSuspendPolicy suspend_policy = SP_NONE;
   {
-    MutexLock mu(event_list_lock_);
+    MutexLock mu(Thread::Current(), event_list_lock_);
     match_list = AllocMatchList(event_list_size_);
     FindMatchingEvents(EK_EXCEPTION, &basket, match_list, &match_count);
     if (match_count != 0) {
@@ -987,7 +987,7 @@
   JdwpSuspendPolicy suspend_policy = SP_NONE;
   int match_count = 0;
   {
-    MutexLock mu(event_list_lock_);
+    MutexLock mu(Thread::Current(), event_list_lock_);
     JdwpEvent** match_list = AllocMatchList(event_list_size_);
     FindMatchingEvents(EK_CLASS_PREPARE, &basket, match_list, &match_count);
     if (match_count != 0) {
diff --git a/src/jdwp/jdwp_main.cc b/src/jdwp/jdwp_main.cc
index 0c3a9a0..69fc2fc 100644
--- a/src/jdwp/jdwp_main.cc
+++ b/src/jdwp/jdwp_main.cc
@@ -47,7 +47,7 @@
  * Write a packet. Grabs a mutex to assure atomicity.
  */
 ssize_t JdwpNetStateBase::writePacket(ExpandBuf* pReply) {
-  MutexLock mu(socket_lock_);
+  MutexLock mu(Thread::Current(), socket_lock_);
   return write(clientSock, expandBufGetBuffer(pReply), expandBufGetLength(pReply));
 }
 
@@ -55,7 +55,7 @@
  * Write a buffered packet. Grabs a mutex to assure atomicity.
  */
 ssize_t JdwpNetStateBase::writeBufferedPacket(const iovec* iov, int iov_count) {
-  MutexLock mu(socket_lock_);
+  MutexLock mu(Thread::Current(), socket_lock_);
   return writev(clientSock, iov, iov_count);
 }
 
@@ -72,7 +72,7 @@
  * packets to the debugger.
  */
 uint32_t JdwpState::NextRequestSerial() {
-  MutexLock mu(serial_lock_);
+  MutexLock mu(Thread::Current(), serial_lock_);
   return request_serial_++;
 }
 
@@ -81,7 +81,7 @@
  * message type EventRequest.Set.
  */
 uint32_t JdwpState::NextEventSerial() {
-  MutexLock mu(serial_lock_);
+  MutexLock mu(Thread::Current(), serial_lock_);
   return event_serial_++;
 }
 
@@ -145,7 +145,7 @@
    * won't signal the cond var before we're waiting.
    */
   {
-    MutexLock thread_start_locker(state->thread_start_lock_);
+    MutexLock thread_start_locker(self, state->thread_start_lock_);
     const bool should_suspend = options->suspend;
     if (!should_suspend) {
       /*
@@ -161,7 +161,7 @@
       state->thread_start_cond_.Wait(self, state->thread_start_lock_);
     } else {
       {
-        MutexLock attach_locker(state->attach_lock_);
+        MutexLock attach_locker(self, 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.
@@ -217,7 +217,7 @@
 
   UnregisterAll();
   {
-    MutexLock mu(event_list_lock_);
+    MutexLock mu(Thread::Current(), event_list_lock_);
     CHECK(event_list_ == NULL);
   }
 
@@ -302,11 +302,8 @@
   }
 
   /* set the thread state to kWaitingInMainDebuggerLoop so GCs don't wait for us */
-  {
-    MutexLock mu(thread_, *Locks::thread_suspend_count_lock_);
-    CHECK_EQ(thread_->GetState(), kNative);
-    thread_->SetState(kWaitingInMainDebuggerLoop);
-  }
+  CHECK_EQ(thread_->GetState(), kNative);
+  thread_->SetState(kWaitingInMainDebuggerLoop);
 
   /*
    * Loop forever if we're in server mode, processing connections.  In
@@ -334,7 +331,7 @@
        */
       if (!(*transport_->establish)(this, options_)) {
         /* wake anybody who was waiting for us to succeed */
-        MutexLock mu(attach_lock_);
+        MutexLock mu(thread_, attach_lock_);
         attach_cond_.Broadcast();
         break;
       }
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 81941c0..16976d4 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -115,11 +115,8 @@
 void Java_MyClassNatives_foo(JNIEnv* env, jobject thisObj) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-    Locks::mutator_lock_->AssertNotHeld(Thread::Current());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
+  Locks::mutator_lock_->AssertNotHeld(Thread::Current());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -169,10 +166,7 @@
 jint Java_MyClassNatives_fooI(JNIEnv* env, jobject thisObj, jint x) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -197,10 +191,7 @@
 jint Java_MyClassNatives_fooII(JNIEnv* env, jobject thisObj, jint x, jint y) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -226,10 +217,7 @@
 jlong Java_MyClassNatives_fooJJ(JNIEnv* env, jobject thisObj, jlong x, jlong y) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -256,10 +244,7 @@
 jdouble Java_MyClassNatives_fooDD(JNIEnv* env, jobject thisObj, jdouble x, jdouble y) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -287,10 +272,7 @@
 jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject thisObj, jlong x, jlong y) {
   // 1 = thisObj
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -315,10 +297,7 @@
                             jobject z) {
   // 3 = this + y + z
   EXPECT_EQ(3U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(thisObj != NULL);
   EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -368,10 +347,7 @@
 jint Java_MyClassNatives_fooSII(JNIEnv* env, jclass klass, jint x, jint y) {
   // 1 = klass
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -393,10 +369,7 @@
 jdouble Java_MyClassNatives_fooSDD(JNIEnv* env, jclass klass, jdouble x, jdouble y) {
   // 1 = klass
   EXPECT_EQ(1U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -424,10 +397,7 @@
                              jobject z) {
   // 3 = klass + y + z
   EXPECT_EQ(3U, Thread::Current()->NumStackReferences());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -478,10 +448,7 @@
 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(*Locks::thread_suspend_count_lock_);
-    EXPECT_EQ(kNative, Thread::Current()->GetState());
-  }
+  EXPECT_EQ(kNative, Thread::Current()->GetState());
   EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
   EXPECT_TRUE(klass != NULL);
   EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 75ab1f0..22438a0 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -195,7 +195,7 @@
   }
   JavaVMExt* vm = soa.Vm();
   IndirectReferenceTable& weak_globals = vm->weak_globals;
-  MutexLock mu(vm->weak_globals_lock);
+  MutexLock mu(soa.Self(), vm->weak_globals_lock);
   IndirectRef ref = weak_globals.Add(IRT_FIRST_SEGMENT, obj);
   return reinterpret_cast<jweak>(ref);
 }
@@ -203,15 +203,27 @@
 static void CheckMethodArguments(AbstractMethod* m, JValue* args)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   MethodHelper mh(m);
-  ObjectArray<Class>* parameter_types = mh.GetParameterTypes();
-  CHECK(parameter_types != NULL);
+  const DexFile::TypeList* params = mh.GetParameterTypeList();
+  if (params == NULL) {
+    return;  // No arguments so nothing to check.
+  }
+  uint32_t num_params = params->Size();
   size_t error_count = 0;
-  for (int i = 0; i < parameter_types->GetLength(); ++i) {
-    Class* parameter_type = parameter_types->Get(i);
-    // TODO: check primitives are in range.
-    if (!parameter_type->IsPrimitive()) {
+  for (uint32_t i = 0; i < num_params; i++) {
+    uint16_t type_idx = params->GetTypeItem(i).type_idx_;
+    Class* param_type = mh.GetClassFromTypeIdx(type_idx);
+    if (param_type == NULL) {
+      Thread* self = Thread::Current();
+      CHECK(self->IsExceptionPending());
+      LOG(ERROR) << "Internal error: unresolvable type for argument type in JNI invoke: "
+          << mh.GetTypeDescriptorFromTypeIdx(type_idx) << "\n"
+          << self->GetException()->Dump();
+      self->ClearException();
+      ++error_count;
+    } else if (!param_type->IsPrimitive()) {
+      // TODO: check primitives are in range.
       Object* argument = args[i].GetL();
-      if (argument != NULL && !argument->InstanceOf(parameter_type)) {
+      if (argument != NULL && !argument->InstanceOf(param_type)) {
         LOG(ERROR) << "JNI ERROR (app bug): attempt to pass an instance of "
                    << PrettyTypeOf(argument) << " as argument " << (i + 1) << " to " << PrettyMethod(m);
         ++error_count;
@@ -382,14 +394,14 @@
 static void PinPrimitiveArray(const ScopedObjectAccess& soa, const Array* array)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   JavaVMExt* vm = soa.Vm();
-  MutexLock mu(vm->pins_lock);
+  MutexLock mu(soa.Self(), vm->pins_lock);
   vm->pin_table.Add(array);
 }
 
 static void UnpinPrimitiveArray(const ScopedObjectAccess& soa, const Array* array)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   JavaVMExt* vm = soa.Vm();
-  MutexLock mu(vm->pins_lock);
+  MutexLock mu(soa.Self(), vm->pins_lock);
   vm->pin_table.Remove(array);
 }
 
@@ -521,7 +533,7 @@
     self->TransitionFromRunnableToSuspended(kWaitingForJniOnLoad);
     bool okay;
     {
-      MutexLock mu(jni_on_load_lock_);
+      MutexLock mu(self, 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
@@ -544,7 +556,7 @@
   }
 
   void SetResult(bool result) LOCKS_EXCLUDED(jni_on_load_lock_) {
-    MutexLock mu(jni_on_load_lock_);
+    MutexLock mu(Thread::Current(), jni_on_load_lock_);
 
     jni_on_load_result_ = result ? kOkay : kFailed;
     jni_on_load_thread_id_ = 0;
@@ -836,7 +848,7 @@
     JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& globals = vm->globals;
     Object* decoded_obj = soa.Decode<Object*>(obj);
-    MutexLock mu(vm->globals_lock);
+    MutexLock mu(soa.Self(), vm->globals_lock);
     IndirectRef ref = globals.Add(IRT_FIRST_SEGMENT, decoded_obj);
     return reinterpret_cast<jobject>(ref);
   }
@@ -848,7 +860,7 @@
     ScopedObjectAccess soa(env);
     JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& globals = vm->globals;
-    MutexLock mu(vm->globals_lock);
+    MutexLock mu(soa.Self(), vm->globals_lock);
 
     if (!globals.Remove(IRT_FIRST_SEGMENT, obj)) {
       LOG(WARNING) << "JNI WARNING: DeleteGlobalRef(" << obj << ") "
@@ -868,7 +880,7 @@
     ScopedObjectAccess soa(env);
     JavaVMExt* vm = soa.Vm();
     IndirectReferenceTable& weak_globals = vm->weak_globals;
-    MutexLock mu(vm->weak_globals_lock);
+    MutexLock mu(soa.Self(), vm->weak_globals_lock);
 
     if (!weak_globals.Remove(IRT_FIRST_SEGMENT, obj)) {
       LOG(WARNING) << "JNI WARNING: DeleteWeakGlobalRef(" << obj << ") "
@@ -918,7 +930,7 @@
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
-    return soa.AddLocalReference<jobject>(c->AllocObject());
+    return soa.AddLocalReference<jobject>(c->AllocObject(soa.Self()));
   }
 
   static jobject NewObject(JNIEnv* env, jclass c, jmethodID mid, ...) {
@@ -935,7 +947,7 @@
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
-    Object* result = c->AllocObject();
+    Object* result = c->AllocObject(soa.Self());
     if (result == NULL) {
       return NULL;
     }
@@ -954,7 +966,7 @@
     if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true, true)) {
       return NULL;
     }
-    Object* result = c->AllocObject();
+    Object* result = c->AllocObject(soa.Self());
     if (result == NULL) {
       return NULL;
     }
@@ -1754,7 +1766,7 @@
 
   static jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) {
     ScopedObjectAccess soa(env);
-    String* result = String::AllocFromUtf16(char_count, chars);
+    String* result = String::AllocFromUtf16(soa.Self(), char_count, chars);
     return soa.AddLocalReference<jstring>(result);
   }
 
@@ -1763,7 +1775,7 @@
       return NULL;
     }
     ScopedObjectAccess soa(env);
-    String* result = String::AllocFromModifiedUtf8(utf);
+    String* result = String::AllocFromModifiedUtf8(soa.Self(), utf);
     return soa.AddLocalReference<jstring>(result);
   }
 
@@ -1923,7 +1935,7 @@
 
     // Allocate and initialize if necessary.
     Class* array_class = soa.Decode<Class*>(java_array_class.get());
-    ObjectArray<Object>* result = ObjectArray<Object>::Alloc(array_class, length);
+    ObjectArray<Object>* result = ObjectArray<Object>::Alloc(soa.Self(), array_class, length);
     if (initial_element != NULL) {
       Object* initial_object = soa.Decode<Object*>(initial_element);
       for (jsize i = 0; i < length; ++i) {
@@ -2297,7 +2309,7 @@
   static JniT NewPrimitiveArray(const ScopedObjectAccess& soa, jsize length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     CHECK_GE(length, 0); // TODO: ReportJniError
-    ArtT* result = ArtT::Alloc(length);
+    ArtT* result = ArtT::Alloc(soa.Self(), length);
     return soa.AddLocalReference<JniT>(result);
   }
 
@@ -2762,16 +2774,17 @@
     os << " (with forcecopy)";
   }
   os << "; workarounds are " << (work_around_app_jni_bugs ? "on" : "off");
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(pins_lock);
+    MutexLock mu(self, pins_lock);
     os << "; pins=" << pin_table.Size();
   }
   {
-    MutexLock mu(globals_lock);
+    MutexLock mu(self, globals_lock);
     os << "; globals=" << globals.Capacity();
   }
   {
-    MutexLock mu(weak_globals_lock);
+    MutexLock mu(self, weak_globals_lock);
     if (weak_globals.Capacity() > 0) {
       os << " (plus " << weak_globals.Capacity() << " weak)";
     }
@@ -2779,22 +2792,23 @@
   os << '\n';
 
   {
-    MutexLock mu(libraries_lock);
+    MutexLock mu(self, libraries_lock);
     os << "Libraries: " << Dumpable<Libraries>(*libraries) << " (" << libraries->size() << ")\n";
   }
 }
 
 void JavaVMExt::DumpReferenceTables(std::ostream& os) {
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(globals_lock);
+    MutexLock mu(self, globals_lock);
     globals.Dump(os);
   }
   {
-    MutexLock mu(weak_globals_lock);
+    MutexLock mu(self, weak_globals_lock);
     weak_globals.Dump(os);
   }
   {
-    MutexLock mu(pins_lock);
+    MutexLock mu(self, pins_lock);
     pin_table.Dump(os);
   }
 }
@@ -2808,9 +2822,10 @@
   // TODO: for better results we should canonicalize the pathname (or even compare
   // inodes). This implementation is fine if everybody is using System.loadLibrary.
   SharedLibrary* library;
+  Thread* self = Thread::Current();
   {
     // TODO: move the locking (and more of this logic) into Libraries.
-    MutexLock mu(libraries_lock);
+    MutexLock mu(self, libraries_lock);
     library = libraries->Get(path);
   }
   if (library != NULL) {
@@ -2847,7 +2862,6 @@
 
   // This can execute slowly for a large library on a busy system, so we
   // want to switch from kRunnable while it executes.  This allows the GC to ignore us.
-  Thread* self = Thread::Current();
   self->TransitionFromRunnableToSuspended(kWaitingForJniOnLoad);
   void* handle = dlopen(path.empty() ? NULL : path.c_str(), RTLD_LAZY);
   self->TransitionFromSuspendedToRunnable();
@@ -2864,7 +2878,7 @@
   // TODO: move the locking (and more of this logic) into Libraries.
   bool created_library = false;
   {
-    MutexLock mu(libraries_lock);
+    MutexLock mu(self, libraries_lock);
     library = libraries->Get(path);
     if (library == NULL) {  // We won race to get libraries_lock
       library = new SharedLibrary(path, handle, class_loader);
@@ -2942,24 +2956,26 @@
 
   std::string detail;
   void* native_method;
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(libraries_lock);
+    MutexLock mu(self, libraries_lock);
     native_method = libraries->FindNativeMethod(m, detail);
   }
   // throwing can cause libraries_lock to be reacquired
   if (native_method == NULL) {
-    Thread::Current()->ThrowNewException("Ljava/lang/UnsatisfiedLinkError;", detail.c_str());
+    self->ThrowNewException("Ljava/lang/UnsatisfiedLinkError;", detail.c_str());
   }
   return native_method;
 }
 
 void JavaVMExt::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(globals_lock);
+    MutexLock mu(self, globals_lock);
     globals.VisitRoots(visitor, arg);
   }
   {
-    MutexLock mu(pins_lock);
+    MutexLock mu(self, pins_lock);
     pin_table.VisitRoots(visitor, arg);
   }
   // The weak_globals table is visited by the GC itself (because it mutates the table).
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index bc1be28..d94da1e 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -93,7 +93,7 @@
                        : c->FindVirtualMethod(method_name, method_signature);
     CHECK(method != NULL);
 
-    receiver = (is_static ? NULL : c->AllocObject());
+    receiver = (is_static ? NULL : c->AllocObject(self));
 
     AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
     CHECK(stub != NULL);
diff --git a/src/logging.cc b/src/logging.cc
index 48785c5..5680ed0 100644
--- a/src/logging.cc
+++ b/src/logging.cc
@@ -105,7 +105,7 @@
 
   // Do the actual logging with the lock held.
   {
-    MutexLock mu(*Locks::logging_lock_);
+    MutexLock mu(Thread::Current(), *Locks::logging_lock_);
     if (msg.find('\n') == std::string::npos) {
       LogLine(msg.c_str());
     } else {
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index e9056f5..96223a9 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -378,7 +378,7 @@
   }
 
   JavaVMExt* vm = Runtime::Current()->GetJavaVM();
-  MutexLock mu(vm->weak_globals_lock);
+  MutexLock mu(Thread::Current(), vm->weak_globals_lock);
   IndirectReferenceTable* table = &vm->weak_globals;
   typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
   for (It it = table->begin(), end = table->end(); it != end; ++it) {
@@ -428,7 +428,7 @@
   runtime->GetMonitorList()->SweepMonitorList(VerifyIsLiveCallback, this);
 
   JavaVMExt* vm = runtime->GetJavaVM();
-  MutexLock mu(vm->weak_globals_lock);
+  MutexLock mu(Thread::Current(), vm->weak_globals_lock);
   IndirectReferenceTable* table = &vm->weak_globals;
   typedef IndirectReferenceTable::iterator It;  // TODO: C++0x auto
   for (It it = table->begin(), end = table->end(); it != end; ++it) {
@@ -440,17 +440,18 @@
 struct SweepCallbackContext {
   MarkSweep* mark_sweep;
   AllocSpace* space;
+  Thread* self;
 };
 
 void MarkSweep::SweepCallback(size_t num_ptrs, Object** ptrs, void* arg) {
-  Locks::heap_bitmap_lock_->AssertExclusiveHeld(Thread::Current());
-
   size_t freed_objects = num_ptrs;
   size_t freed_bytes = 0;
   SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
   MarkSweep* mark_sweep = context->mark_sweep;
   Heap* heap = mark_sweep->GetHeap();
   AllocSpace* space = context->space;
+  Thread* self = context->self;
+  Locks::heap_bitmap_lock_->AssertExclusiveHeld(self);
   // Use a bulk free, that merges consecutive objects before freeing or free per object?
   // Documentation suggests better free performance with merging, but this may be at the expensive
   // of allocation.
@@ -462,12 +463,12 @@
       freed_bytes += space->AllocationSize(obj);
     }
     // AllocSpace::FreeList clears the value in ptrs, so perform after clearing the live bit
-    space->FreeList(num_ptrs, ptrs);
+    space->FreeList(self, num_ptrs, ptrs);
   } else {
     for (size_t i = 0; i < num_ptrs; ++i) {
       Object* obj = static_cast<Object*>(ptrs[i]);
       freed_bytes += space->AllocationSize(obj);
-      space->Free(obj);
+      space->Free(self, obj);
     }
   }
 
@@ -477,9 +478,8 @@
 }
 
 void MarkSweep::ZygoteSweepCallback(size_t num_ptrs, Object** ptrs, void* arg) {
-  Locks::heap_bitmap_lock_->AssertExclusiveHeld(Thread::Current());
-
   SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
+  Locks::heap_bitmap_lock_->AssertExclusiveHeld(context->self);
   Heap* heap = context->mark_sweep->GetHeap();
   // We don't free any actual memory to avoid dirtying the shared zygote pages.
   for (size_t i = 0; i < num_ptrs; ++i) {
@@ -516,6 +516,7 @@
   Object** out = objects;
 
   // Empty the allocation stack.
+  Thread* self = Thread::Current();
   for (size_t i = 0;i < count;++i) {
     Object* obj = objects[i];
     // There should only be objects in the AllocSpace/LargeObjectSpace in the allocation stack.
@@ -530,7 +531,7 @@
       ++freed_large_objects;
       size_t size = large_object_space->AllocationSize(obj);
       freed_bytes += size;
-      large_object_space->Free(obj);
+      large_object_space->Free(self, obj);
     }
   }
   logger.AddSplit("Process allocation stack");
@@ -538,7 +539,7 @@
   size_t freed_objects = out - objects;
   VLOG(heap) << "Freed " << freed_objects << "/" << count
              << " objects with size " << PrettySize(freed_bytes);
-  space->FreeList(freed_objects, objects);
+  space->FreeList(self, freed_objects, objects);
   heap_->RecordFree(freed_objects + freed_large_objects, freed_bytes);
   freed_objects_ += freed_objects;
   freed_bytes_ += freed_bytes;
@@ -557,6 +558,7 @@
   const Spaces& spaces = heap_->GetSpaces();
   SweepCallbackContext scc;
   scc.mark_sweep = this;
+  scc.self = Thread::Current();
   // TODO: C++0x auto
   for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
     ContinuousSpace* space = *it;
@@ -598,10 +600,11 @@
   size_t freed_objects = 0;
   size_t freed_bytes = 0;
   // TODO: C++0x
+  Thread* self = Thread::Current();
   for (SpaceSetMap::Objects::iterator it = live_objects.begin(); it != live_objects.end(); ++it) {
     if (!large_mark_objects->Test(*it)) {
       freed_bytes += large_object_space->AllocationSize(*it);
-      large_object_space->Free(const_cast<Object*>(*it));
+      large_object_space->Free(self, const_cast<Object*>(*it));
       ++freed_objects;
     }
   }
diff --git a/src/monitor.cc b/src/monitor.cc
index c0484af..9890822 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -284,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.
-    MutexLock mu(*Locks::thread_list_lock_);
+    MutexLock mu(Thread::Current(), *Locks::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.
@@ -427,7 +427,7 @@
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before wait()");
     return;
   }
-  monitor_lock_.AssertHeld();
+  monitor_lock_.AssertHeld(self);
   WaitWithLock(self, ms, ns, interruptShouldThrow);
 }
 
@@ -476,7 +476,7 @@
   bool wasInterrupted = false;
   {
     // Pseudo-atomically wait on self's wait_cond_ and release the monitor lock.
-    MutexLock mu(*self->wait_mutex_);
+    MutexLock mu(self, *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
@@ -538,7 +538,7 @@
      * cleared when this exception is thrown."
      */
     {
-      MutexLock mu(*self->wait_mutex_);
+      MutexLock mu(self, *self->wait_mutex_);
       self->interrupted_ = false;
     }
     if (interruptShouldThrow) {
@@ -554,11 +554,11 @@
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before notify()");
     return;
   }
-  monitor_lock_.AssertHeld();
-  NotifyWithLock();
+  monitor_lock_.AssertHeld(self);
+  NotifyWithLock(self);
 }
 
-void Monitor::NotifyWithLock() {
+void Monitor::NotifyWithLock(Thread* self) {
   // Signal the first waiting thread in the wait set.
   while (wait_set_ != NULL) {
     Thread* thread = wait_set_;
@@ -566,7 +566,7 @@
     thread->wait_next_ = NULL;
 
     // Check to see if the thread is still waiting.
-    MutexLock mu(*thread->wait_mutex_);
+    MutexLock mu(self, *thread->wait_mutex_);
     if (thread->wait_monitor_ != NULL) {
       thread->wait_cond_->Signal();
       return;
@@ -581,7 +581,7 @@
     ThrowIllegalMonitorStateExceptionF("object not locked by thread before notifyAll()");
     return;
   }
-  monitor_lock_.AssertHeld();
+  monitor_lock_.AssertHeld(self);
   NotifyAllWithLock();
 }
 
@@ -872,10 +872,7 @@
 
 void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
   ThreadState state;
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    state = thread->GetState();
-  }
+  state = thread->GetState();
 
   Object* object = NULL;
   uint32_t lock_owner = ThreadList::kInvalidId;
@@ -883,7 +880,7 @@
     os << "  - waiting on ";
     Monitor* monitor;
     {
-      MutexLock mu(*thread->wait_mutex_);
+      MutexLock mu(Thread::Current(), *thread->wait_mutex_);
       monitor = thread->wait_monitor_;
     }
     if (monitor != NULL) {
@@ -1002,17 +999,17 @@
 }
 
 MonitorList::~MonitorList() {
-  MutexLock mu(monitor_list_lock_);
+  MutexLock mu(Thread::Current(), monitor_list_lock_);
   STLDeleteElements(&list_);
 }
 
 void MonitorList::Add(Monitor* m) {
-  MutexLock mu(monitor_list_lock_);
+  MutexLock mu(Thread::Current(), monitor_list_lock_);
   list_.push_front(m);
 }
 
 void MonitorList::SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg) {
-  MutexLock mu(monitor_list_lock_);
+  MutexLock mu(Thread::Current(), 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 4a62728..4277d2c 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -115,7 +115,7 @@
   bool Unlock(Thread* thread, bool for_wait) UNLOCK_FUNCTION(monitor_lock_);
 
   void Notify(Thread* self) NO_THREAD_SAFETY_ANALYSIS;
-  void NotifyWithLock()
+  void NotifyWithLock(Thread* self)
       EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/src/mutex.cc b/src/mutex.cc
index 522f849..96e04ef 100644
--- a/src/mutex.cc
+++ b/src/mutex.cc
@@ -196,7 +196,7 @@
   if (rc != 0) {
     errno = rc;
     // TODO: should we just not log at all if shutting down? this could be the logging mutex!
-    MutexLock mu(*Locks::runtime_shutdown_lock_);
+    MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
     Runtime* runtime = Runtime::Current();
     bool shutting_down = (runtime == NULL) || runtime->IsShuttingDown();
     PLOG(shutting_down ? WARNING : FATAL) << "pthread_mutex_destroy failed for " << name_;
@@ -329,7 +329,7 @@
   if (rc != 0) {
     errno = rc;
     // TODO: should we just not log at all if shutting down? this could be the logging mutex!
-    MutexLock mu(*Locks::runtime_shutdown_lock_);
+    MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
     Runtime* runtime = Runtime::Current();
     bool shutting_down = runtime == NULL || runtime->IsShuttingDown();
     PLOG(shutting_down ? WARNING : FATAL) << "pthread_rwlock_destroy failed for " << name_;
@@ -586,7 +586,7 @@
   int rc = pthread_cond_destroy(&cond_);
   if (rc != 0) {
     errno = rc;
-    MutexLock mu(*Locks::runtime_shutdown_lock_);
+    MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
     Runtime* runtime = Runtime::Current();
     bool shutting_down = (runtime == NULL) || runtime->IsShuttingDown();
     PLOG(shutting_down ? WARNING : FATAL) << "pthread_cond_destroy failed for " << name_;
diff --git a/src/mutex.h b/src/mutex.h
index 32aeaf9..d51e2cc 100644
--- a/src/mutex.h
+++ b/src/mutex.h
@@ -25,8 +25,8 @@
 
 #include "globals.h"
 #include "locks.h"
+#include "logging.h"
 #include "macros.h"
-#include "thread.h"
 
 #if defined(__APPLE__)
 #define ART_USE_FUTEXES 0
@@ -43,6 +43,8 @@
 
 namespace art {
 
+class Thread;
+
 const bool kDebugLocking = kIsDebugBuild;
 
 // Base class for all Mutex implementations
@@ -110,7 +112,6 @@
     }
   }
   void AssertHeld(const Thread* self) { AssertExclusiveHeld(self); }
-  void AssertHeld() { AssertExclusiveHeld(Thread::Current()); }
 
   // Assert that the Mutex is not held by the current thread.
   void AssertNotHeldExclusive(const Thread* self) {
@@ -275,10 +276,6 @@
     mu_.ExclusiveLock(self_);
   }
 
-  explicit MutexLock(Mutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) : self_(Thread::Current()), mu_(mu) {
-    mu_.ExclusiveLock(self_);
-  }
-
   ~MutexLock() UNLOCK_FUNCTION() {
     mu_.ExclusiveUnlock(self_);
   }
@@ -300,11 +297,6 @@
     mu_.SharedLock(self_);
   }
 
-  explicit ReaderMutexLock(ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) :
-      self_(Thread::Current()), mu_(mu) {
-    mu_.SharedLock(self_);
-  }
-
   ~ReaderMutexLock() UNLOCK_FUNCTION() {
     mu_.SharedUnlock(self_);
   }
@@ -327,17 +319,12 @@
     mu_.ExclusiveLock(self_);
   }
 
-  explicit WriterMutexLock(ReaderWriterMutex& mu) EXCLUSIVE_LOCK_FUNCTION(mu) :
-      self_(Thread::Current()), mu_(mu) {
-    mu_.ExclusiveLock(self_);
-  }
-
   ~WriterMutexLock() UNLOCK_FUNCTION() {
     mu_.ExclusiveUnlock(self_);
   }
 
  private:
-  Thread* self_;
+  Thread* const self_;
   ReaderWriterMutex& mu_;
   DISALLOW_COPY_AND_ASSIGN(WriterMutexLock);
 };
diff --git a/src/native/dalvik_system_VMRuntime.cc b/src/native/dalvik_system_VMRuntime.cc
index 7184e48..91b7b5f 100644
--- a/src/native/dalvik_system_VMRuntime.cc
+++ b/src/native/dalvik_system_VMRuntime.cc
@@ -54,11 +54,11 @@
 
   Class* element_class = soa.Decode<Class*>(javaElementClass);
   if (element_class == NULL) {
-    Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "element class == null");
+    soa.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "element class == null");
     return NULL;
   }
   if (length < 0) {
-    Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", length);
+    soa.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", length);
     return NULL;
   }
 
@@ -67,7 +67,7 @@
   descriptor += "[";
   descriptor += ClassHelper(element_class).GetDescriptor();
   Class* array_class = class_linker->FindClass(descriptor.c_str(), NULL);
-  Array* result = Array::Alloc(array_class, length);
+  Array* result = Array::Alloc(soa.Self(), array_class, length);
   if (result == NULL) {
     return NULL;
   }
@@ -81,7 +81,7 @@
   ScopedObjectAccess soa(env);
   Array* array = soa.Decode<Array*>(javaArray);
   if (!array->IsArrayInstance()) {
-    Thread::Current()->ThrowNewException("Ljava/lang/IllegalArgumentException;", "not an array");
+    soa.Self()->ThrowNewException("Ljava/lang/IllegalArgumentException;", "not an array");
     return 0;
   }
   // TODO: we should also check that this is a non-movable array.
@@ -127,7 +127,7 @@
 }
 #endif
 
-static void VMRuntime_setTargetSdkVersion(JNIEnv*, jobject, jint targetSdkVersion) {
+static void VMRuntime_setTargetSdkVersion(JNIEnv* env, jobject, jint targetSdkVersion) {
   // This is the target SDK version of the app we're about to run.
   // Note that targetSdkVersion may be CUR_DEVELOPMENT (10000).
   // Note that targetSdkVersion may be 0, meaning "current".
@@ -138,7 +138,8 @@
 #if !defined(ART_USE_LLVM_COMPILER)
     if (vm->check_jni) {
       LOG(WARNING) << "Turning off CheckJNI so we can turn on JNI app bug workarounds...";
-      MutexLock mu(*Locks::thread_list_lock_);
+      Thread* self = static_cast<JNIEnvExt*>(env)->self;
+      MutexLock mu(self, *Locks::thread_list_lock_);
       vm->SetCheckJniEnabled(false);
       runtime->GetThreadList()->ForEach(DisableCheckJniCallback, NULL);
     }
@@ -148,6 +149,7 @@
 
     vm->work_around_app_jni_bugs = true;
 #else
+    UNUSED(env);
     LOG(WARNING) << "LLVM does not work-around app jni bugs.";
     vm->work_around_app_jni_bugs = false;
 #endif
diff --git a/src/native/java_lang_Class.cc b/src/native/java_lang_Class.cc
index c023b7e..488df80 100644
--- a/src/native/java_lang_Class.cc
+++ b/src/native/java_lang_Class.cc
@@ -199,7 +199,8 @@
     AbstractMethod* m = c->GetVirtualMethod(i);
     mh.ChangeMethod(m);
     if (IsVisibleMethod(m, publicOnly)) {
-      if (mh.GetReturnType() == NULL || mh.GetParameterTypes() == NULL) {
+      // TODO: the use of GetParameterTypes creates an unused array here.
+      if (mh.GetReturnType() == NULL || mh.GetParameterTypes(soa.Self()) == NULL) {
         DCHECK(env->ExceptionOccurred());
         return NULL;
       }
@@ -213,7 +214,8 @@
     AbstractMethod* m = c->GetDirectMethod(i);
     mh.ChangeMethod(m);
     if (IsVisibleMethod(m, publicOnly)) {
-      if (mh.GetReturnType() == NULL || mh.GetParameterTypes() == NULL) {
+      // TODO: the use of GetParameterTypes creates an unused array here.
+      if (mh.GetReturnType() == NULL || mh.GetParameterTypes(soa.Self()) == NULL) {
         DCHECK(env->ExceptionOccurred());
         return NULL;
       }
@@ -349,7 +351,7 @@
 static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
   ScopedObjectAccess soa(env);
   SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(soa, javaThis));
-  return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone());
+  return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone(soa.Self()));
 }
 
 static jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
@@ -412,7 +414,7 @@
     return NULL;
   }
 
-  Object* new_obj = c->AllocObject();
+  Object* new_obj = c->AllocObject(soa.Self());
   if (new_obj == NULL) {
     DCHECK(soa.Self()->IsExceptionPending());
     return NULL;
diff --git a/src/native/java_lang_Object.cc b/src/native/java_lang_Object.cc
index 89019f7..a6ae49d 100644
--- a/src/native/java_lang_Object.cc
+++ b/src/native/java_lang_Object.cc
@@ -23,7 +23,7 @@
 static jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
   ScopedObjectAccess soa(env);
   Object* o = soa.Decode<Object*>(javaThis);
-  return soa.AddLocalReference<jobject>(o->Clone());
+  return soa.AddLocalReference<jobject>(o->Clone(soa.Self()));
 }
 
 static void Object_notify(JNIEnv* env, jobject javaThis) {
diff --git a/src/native/java_lang_Thread.cc b/src/native/java_lang_Thread.cc
index edf55c3..cf475e2 100644
--- a/src/native/java_lang_Thread.cc
+++ b/src/native/java_lang_Thread.cc
@@ -34,7 +34,7 @@
 
 static jboolean Thread_isInterrupted(JNIEnv* env, jobject java_thread) {
   ScopedObjectAccess soa(env);
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = Thread::FromManagedThread(soa, java_thread);
   return (thread != NULL) ? thread->IsInterrupted() : JNI_FALSE;
 }
@@ -55,10 +55,9 @@
 
   ScopedObjectAccess soa(env);
   ThreadState internal_thread_state = (has_been_started ? kTerminated : kStarting);
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread != NULL) {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
     internal_thread_state = thread->GetState();
   }
   switch (internal_thread_state) {
@@ -91,7 +90,7 @@
     Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "object == null");
     return JNI_FALSE;
   }
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = Thread::FromManagedThread(soa, java_thread);
   return thread->HoldsLock(object);
 }
@@ -138,7 +137,7 @@
  */
 static void Thread_nativeSetPriority(JNIEnv* env, jobject java_thread, jint new_priority) {
   ScopedObjectAccess soa(env);
-  MutexLock mu(*Locks::thread_list_lock_);
+  MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
   Thread* thread = Thread::FromManagedThread(soa, java_thread);
   if (thread != NULL) {
     thread->SetNativePriority(new_priority);
diff --git a/src/native/java_lang_reflect_Array.cc b/src/native/java_lang_reflect_Array.cc
index d3a57bf..863f9fc 100644
--- a/src/native/java_lang_reflect_Array.cc
+++ b/src/native/java_lang_reflect_Array.cc
@@ -29,7 +29,7 @@
                                IntArray* dimensions)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   int32_t array_length = dimensions->Get(current_dimension++);
-  SirtRef<Array> new_array(self, Array::Alloc(array_class, array_length));
+  SirtRef<Array> new_array(self, Array::Alloc(self, array_class, array_length));
   if (new_array.get() == NULL) {
     CHECK(self->IsExceptionPending());
     return NULL;
@@ -139,7 +139,7 @@
     return NULL;
   }
   DCHECK(array_class->IsArrayClass());
-  Array* new_array = Array::Alloc(array_class, length);
+  Array* new_array = Array::Alloc(soa.Self(), array_class, length);
   if (new_array == NULL) {
     CHECK(soa.Self()->IsExceptionPending());
     return NULL;
diff --git a/src/native/java_lang_reflect_Constructor.cc b/src/native/java_lang_reflect_Constructor.cc
index 44b459d..ed0d1f1 100644
--- a/src/native/java_lang_reflect_Constructor.cc
+++ b/src/native/java_lang_reflect_Constructor.cc
@@ -45,7 +45,7 @@
     return NULL;
   }
 
-  Object* receiver = c->AllocObject();
+  Object* receiver = c->AllocObject(soa.Self());
   if (receiver == NULL) {
     return NULL;
   }
diff --git a/src/native/java_lang_reflect_Method.cc b/src/native/java_lang_reflect_Method.cc
index 63a277b..b1eb6e0 100644
--- a/src/native/java_lang_reflect_Method.cc
+++ b/src/native/java_lang_reflect_Method.cc
@@ -44,7 +44,7 @@
   }
   CHECK_NE(throws_index, -1);
   ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
-  return soa.AddLocalReference<jobject>(declared_exceptions->Clone());
+  return soa.AddLocalReference<jobject>(declared_exceptions->Clone(soa.Self()));
 }
 
 static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
diff --git a/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc b/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
index 66c27e4..0ed964b 100644
--- a/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
+++ b/src/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
@@ -39,7 +39,7 @@
   return Dbg::IsAllocTrackingEnabled();
 }
 
-static jobject FindThreadByThinLockId(JNIEnv*, 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) {
     }
@@ -56,7 +56,8 @@
   };
   ThreadFinder finder(thin_lock_id);
   {
-    MutexLock mu(*Locks::thread_list_lock_);
+    Thread* self = static_cast<JNIEnvExt*>(env)->self;
+    MutexLock mu(self, *Locks::thread_list_lock_);
     Runtime::Current()->GetThreadList()->ForEach(ThreadFinder::Callback, &finder);
   }
   if (finder.thread != NULL) {
@@ -133,10 +134,7 @@
 
   std::vector<uint8_t>& bytes = *reinterpret_cast<std::vector<uint8_t>*>(context);
   JDWP::Append4BE(bytes, t->GetThinLockId());
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    JDWP::Append1BE(bytes, t->GetState());
-  }
+  JDWP::Append1BE(bytes, t->GetState());
   JDWP::Append4BE(bytes, t->GetTid());
   JDWP::Append4BE(bytes, utime);
   JDWP::Append4BE(bytes, stime);
@@ -145,8 +143,9 @@
 
 static jbyteArray DdmVmInternal_getThreadStats(JNIEnv* env, jclass) {
   std::vector<uint8_t> bytes;
+  Thread* self = static_cast<JNIEnvExt*>(env)->self;
   {
-    MutexLock mu(*Locks::thread_list_lock_);
+    MutexLock mu(self, *Locks::thread_list_lock_);
     ThreadList* thread_list = Runtime::Current()->GetThreadList();
 
     uint16_t thread_count = 0;
diff --git a/src/oat/runtime/arm/stub_arm.cc b/src/oat/runtime/arm/stub_arm.cc
index 7add255..4099ddb 100644
--- a/src/oat/runtime/arm/stub_arm.cc
+++ b/src/oat/runtime/arm/stub_arm.cc
@@ -82,7 +82,8 @@
 
   assembler->EmitSlowPaths();
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> resolution_trampoline(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
   CHECK(resolution_trampoline.get() != NULL);
   MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
   assembler->FinalizeInstructions(code);
@@ -128,7 +129,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> abstract_stub(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
   CHECK(abstract_stub.get() != NULL);
   MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
   assembler->FinalizeInstructions(code);
@@ -156,7 +158,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> jni_stub(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
   CHECK(jni_stub.get() != NULL);
   MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
   assembler->FinalizeInstructions(code);
diff --git a/src/oat/runtime/mips/stub_mips.cc b/src/oat/runtime/mips/stub_mips.cc
index d545e4a..9691308 100644
--- a/src/oat/runtime/mips/stub_mips.cc
+++ b/src/oat/runtime/mips/stub_mips.cc
@@ -112,7 +112,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> resolution_trampoline(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
   CHECK(resolution_trampoline.get() != NULL);
   MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
   assembler->FinalizeInstructions(code);
@@ -157,7 +158,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> abstract_stub(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
   CHECK(abstract_stub.get() != NULL);
   MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
   assembler->FinalizeInstructions(code);
@@ -197,7 +199,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> jni_stub(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
   CHECK(jni_stub.get() != NULL);
   MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
   assembler->FinalizeInstructions(code);
diff --git a/src/oat/runtime/support_alloc.cc b/src/oat/runtime/support_alloc.cc
index fd7fb65..fb70285 100644
--- a/src/oat/runtime/support_alloc.cc
+++ b/src/oat/runtime/support_alloc.cc
@@ -37,7 +37,7 @@
                                         Thread* self, AbstractMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  return AllocArrayFromCode(type_idx, method, component_count, false);
+  return AllocArrayFromCode(type_idx, method, component_count, self, false);
 }
 
 extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, AbstractMethod* method,
@@ -45,7 +45,7 @@
                                                        Thread* self, AbstractMethod** sp)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
-  return AllocArrayFromCode(type_idx, method, component_count, true);
+  return AllocArrayFromCode(type_idx, method, component_count, self, true);
 }
 
 extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method,
diff --git a/src/oat/runtime/support_proxy.cc b/src/oat/runtime/support_proxy.cc
index 4ff2e5f..3d0c1c8 100644
--- a/src/oat/runtime/support_proxy.cc
+++ b/src/oat/runtime/support_proxy.cc
@@ -104,7 +104,7 @@
   args_jobj[2].l = NULL;
   ObjectArray<Object>* args = NULL;
   if ((num_params - 1) > 0) {
-    args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(num_params - 1);
+    args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(self, num_params - 1);
     if (args == NULL) {
       CHECK(self->IsExceptionPending());
       return;
@@ -120,7 +120,7 @@
   cur_arg = 0;  // reset stack location to read to start
   // reset index, will index into param type array which doesn't include the receiver
   param_index = 0;
-  ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes();
+  ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes(self);
   if (param_types == NULL) {
     CHECK(self->IsExceptionPending());
     return;
diff --git a/src/oat/runtime/x86/stub_x86.cc b/src/oat/runtime/x86/stub_x86.cc
index 7941d15..cade99d 100644
--- a/src/oat/runtime/x86/stub_x86.cc
+++ b/src/oat/runtime/x86/stub_x86.cc
@@ -92,7 +92,8 @@
 
   assembler->EmitSlowPaths();
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> resolution_trampoline(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
   CHECK(resolution_trampoline.get() != NULL);
   MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
   assembler->FinalizeInstructions(code);
@@ -146,7 +147,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> abstract_stub(Thread::Current(),ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
   CHECK(abstract_stub.get() != NULL);
   MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
   assembler->FinalizeInstructions(code);
@@ -179,7 +181,8 @@
   assembler->EmitSlowPaths();
 
   size_t cs = assembler->CodeSize();
-  SirtRef<ByteArray> jni_stub(Thread::Current(), ByteArray::Alloc(cs));
+  Thread* self = Thread::Current();
+  SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
   CHECK(jni_stub.get() != NULL);
   MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
   assembler->FinalizeInstructions(code);
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 7e14199..01b2042 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -575,11 +575,12 @@
     // Loop through all the image spaces and dump their objects.
     Heap* heap = Runtime::Current()->GetHeap();
     const Spaces& spaces = heap->GetSpaces();
+    Thread* self = Thread::Current();
     {
-      WriterMutexLock mu(*Locks::heap_bitmap_lock_);
+      WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
       heap->FlushAllocStack();
     }
-    ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
+    ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
     // TODO: C++0x auto
     for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
       Space* space = *it;
diff --git a/src/object.cc b/src/object.cc
index 8582a21..e8381db 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -47,7 +47,7 @@
   return down_cast<String*>(this);
 }
 
-Object* Object::Clone() {
+Object* Object::Clone(Thread* self) {
   Class* c = GetClass();
   DCHECK(!c->IsClassClass());
 
@@ -55,7 +55,7 @@
   // Using c->AllocObject() here would be wrong.
   size_t num_bytes = SizeOf();
   Heap* heap = Runtime::Current()->GetHeap();
-  SirtRef<Object> copy(Thread::Current(), heap->AllocObject(c, num_bytes));
+  SirtRef<Object> copy(self, heap->AllocObject(self, c, num_bytes));
   if (copy.get() == NULL) {
     return NULL;
   }
@@ -727,13 +727,13 @@
   SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache, false);
 }
 
-Object* Class::AllocObject() {
+Object* Class::AllocObject(Thread* self) {
   DCHECK(!IsArrayClass()) << PrettyClass(this);
   DCHECK(IsInstantiable()) << PrettyClass(this);
   // TODO: decide whether we want this check. It currently fails during bootstrap.
   // DCHECK(!Runtime::Current()->IsStarted() || IsInitializing()) << PrettyClass(this);
   DCHECK_GE(this->object_size_, sizeof(Object));
-  return Runtime::Current()->GetHeap()->AllocObject(this, this->object_size_);
+  return Runtime::Current()->GetHeap()->AllocObject(self, this, this->object_size_);
 }
 
 void Class::SetClassSize(size_t new_class_size) {
@@ -768,7 +768,7 @@
     default:
       LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]);
     }
-    name = String::AllocFromModifiedUtf8(c_name);
+    name = String::AllocFromModifiedUtf8(Thread::Current(), c_name);
   } else {
     // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package
     // components.
@@ -777,7 +777,7 @@
       descriptor.erase(descriptor.size() - 1);
     }
     std::replace(descriptor.begin(), descriptor.end(), '/', '.');
-    name = String::AllocFromModifiedUtf8(descriptor.c_str());
+    name = String::AllocFromModifiedUtf8(Thread::Current(), descriptor.c_str());
   }
   SetName(name);
   return name;
@@ -1288,7 +1288,8 @@
   return NULL;
 }
 
-Array* Array::Alloc(Class* array_class, int32_t component_count, size_t component_size) {
+Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
+                    size_t component_size) {
   DCHECK(array_class != NULL);
   DCHECK_GE(component_count, 0);
   DCHECK(array_class->IsArrayClass());
@@ -1300,14 +1301,14 @@
   // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
   size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
   if (data_size >> component_shift != size_t(component_count) || size < data_size) {
-    Thread::Current()->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
+    self->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
         "%s of length %d would overflow",
         PrettyDescriptor(array_class).c_str(), component_count);
     return NULL;
   }
 
   Heap* heap = Runtime::Current()->GetHeap();
-  Array* array = down_cast<Array*>(heap->AllocObject(array_class, size));
+  Array* array = down_cast<Array*>(heap->AllocObject(self, array_class, size));
   if (array != NULL) {
     DCHECK(array->IsArrayInstance());
     array->SetLength(component_count);
@@ -1315,9 +1316,9 @@
   return array;
 }
 
-Array* Array::Alloc(Class* array_class, int32_t component_count) {
+Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count) {
   DCHECK(array_class->IsArrayClass());
-  return Alloc(array_class, component_count, array_class->GetComponentSize());
+  return Alloc(self, array_class, component_count, array_class->GetComponentSize());
 }
 
 bool Array::ThrowArrayIndexOutOfBoundsException(int32_t index) const {
@@ -1334,9 +1335,9 @@
 }
 
 template<typename T>
-PrimitiveArray<T>* PrimitiveArray<T>::Alloc(size_t length) {
+PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
   DCHECK(array_class_ != NULL);
-  Array* raw_array = Array::Alloc(array_class_, length, sizeof(T));
+  Array* raw_array = Array::Alloc(self, array_class_, length, sizeof(T));
   return down_cast<PrimitiveArray<T>*>(raw_array);
 }
 
@@ -1402,11 +1403,12 @@
   return GetCharArray()->Get(index + GetOffset());
 }
 
-String* String::AllocFromUtf16(int32_t utf16_length,
+String* String::AllocFromUtf16(Thread* self,
+                               int32_t utf16_length,
                                const uint16_t* utf16_data_in,
                                int32_t hash_code) {
   CHECK(utf16_data_in != NULL || utf16_length == 0);
-  String* string = Alloc(GetJavaLangString(), utf16_length);
+  String* string = Alloc(self, GetJavaLangString(), utf16_length);
   if (string == NULL) {
     return NULL;
   }
@@ -1426,17 +1428,17 @@
   return string;
 }
 
-String* String::AllocFromModifiedUtf8(const char* utf) {
+  String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) {
   if (utf == NULL) {
     return NULL;
   }
   size_t char_count = CountModifiedUtf8Chars(utf);
-  return AllocFromModifiedUtf8(char_count, utf);
+  return AllocFromModifiedUtf8(self, char_count, utf);
 }
 
-String* String::AllocFromModifiedUtf8(int32_t utf16_length,
+String* String::AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
                                       const char* utf8_data_in) {
-  String* string = Alloc(GetJavaLangString(), utf16_length);
+  String* string = Alloc(self, GetJavaLangString(), utf16_length);
   if (string == NULL) {
     return NULL;
   }
@@ -1447,18 +1449,18 @@
   return string;
 }
 
-String* String::Alloc(Class* java_lang_String, int32_t utf16_length) {
-  SirtRef<CharArray> array(Thread::Current(), CharArray::Alloc(utf16_length));
+String* String::Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length) {
+  SirtRef<CharArray> array(self, CharArray::Alloc(self, utf16_length));
   if (array.get() == NULL) {
     return NULL;
   }
-  return Alloc(java_lang_String, array.get());
+  return Alloc(self, java_lang_String, array.get());
 }
 
-String* String::Alloc(Class* java_lang_String, CharArray* array) {
+String* String::Alloc(Thread* self, Class* java_lang_String, CharArray* array) {
   // Hold reference in case AllocObject causes GC.
-  SirtRef<CharArray> array_ref(Thread::Current(), array);
-  String* string = down_cast<String*>(java_lang_String->AllocObject());
+  SirtRef<CharArray> array_ref(self, array);
+  String* string = down_cast<String*>(java_lang_String->AllocObject(self));
   if (string == NULL) {
     return NULL;
   }
@@ -1610,12 +1612,13 @@
   java_lang_StackTraceElement_ = NULL;
 }
 
-StackTraceElement* StackTraceElement::Alloc(String* declaring_class,
+StackTraceElement* StackTraceElement::Alloc(Thread* self,
+                                            String* declaring_class,
                                             String* method_name,
                                             String* file_name,
                                             int32_t line_number) {
   StackTraceElement* trace =
-      down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject());
+      down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject(self));
   trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_),
                         const_cast<String*>(declaring_class), false);
   trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_),
diff --git a/src/object.h b/src/object.h
index 5fccb04..baa7313 100644
--- a/src/object.h
+++ b/src/object.h
@@ -177,7 +177,7 @@
 
   size_t SizeOf() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  Object* Clone() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Object* Clone(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   int32_t IdentityHashCode() const {
   #ifdef MOVING_GARBAGE_COLLECTOR
@@ -1054,10 +1054,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(Thread* self, Class* array_class, int32_t component_count)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static Array* Alloc(Class* array_class, int32_t component_count, size_t component_size)
+  static Array* Alloc(Thread* self, Class* array_class, int32_t component_count,
+                      size_t component_size)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   size_t SizeOf() const;
@@ -1121,7 +1122,7 @@
 template<class T>
 class MANAGED ObjectArray : public Array {
  public:
-  static ObjectArray<T>* Alloc(Class* object_array_class, int32_t length)
+  static ObjectArray<T>* Alloc(Thread* self, Class* object_array_class, int32_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   T* Get(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -1139,7 +1140,7 @@
                    size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  ObjectArray<T>* CopyOf(int32_t new_length)
+  ObjectArray<T>* CopyOf(Thread* self, int32_t new_length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
  private:
@@ -1147,8 +1148,8 @@
 };
 
 template<class T>
-ObjectArray<T>* ObjectArray<T>::Alloc(Class* object_array_class, int32_t length) {
-  Array* array = Array::Alloc(object_array_class, length, sizeof(Object*));
+ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class, int32_t length) {
+  Array* array = Array::Alloc(self, object_array_class, length, sizeof(Object*));
   if (UNLIKELY(array == NULL)) {
     return NULL;
   } else {
@@ -1166,8 +1167,8 @@
 }
 
 template<class T>
-ObjectArray<T>* ObjectArray<T>::CopyOf(int32_t new_length) {
-  ObjectArray<T>* new_array = Alloc(GetClass(), new_length);
+ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
+  ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length);
   Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
   return new_array;
 }
@@ -1450,7 +1451,7 @@
   }
 
   // Creates a raw object instance but does not invoke the default constructor.
-  Object* AllocObject() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  Object* AllocObject(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool IsVariableSize() const {
     // Classes and arrays vary in size, and so the object_size_ field cannot
@@ -2282,7 +2283,7 @@
  public:
   typedef T ElementType;
 
-  static PrimitiveArray<T>* Alloc(size_t length)
+  static PrimitiveArray<T>* Alloc(Thread* self, size_t length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   const T* GetData() const {
@@ -2370,22 +2371,23 @@
 
   String* Intern() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static String* AllocFromUtf16(int32_t utf16_length,
+  static String* AllocFromUtf16(Thread* self,
+                                int32_t utf16_length,
                                 const uint16_t* utf16_data_in,
                                 int32_t hash_code = 0)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static String* AllocFromModifiedUtf8(const char* utf)
+  static String* AllocFromModifiedUtf8(Thread* self, const char* utf)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static String* AllocFromModifiedUtf8(int32_t utf16_length,
+  static String* AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
                                        const char* utf8_data_in)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static String* Alloc(Class* java_lang_String, int32_t utf16_length)
+  static String* Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  static String* Alloc(Class* java_lang_String, CharArray* array)
+  static String* Alloc(Thread* self, Class* java_lang_String, CharArray* array)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool Equals(const char* modified_utf8) const
@@ -2617,7 +2619,8 @@
         OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_), false);
   }
 
-  static StackTraceElement* Alloc(String* declaring_class,
+  static StackTraceElement* Alloc(Thread* self,
+                                  String* declaring_class,
                                   String* method_name,
                                   String* file_name,
                                   int32_t line_number)
diff --git a/src/object_test.cc b/src/object_test.cc
index f28c20b..9ad0534 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -44,7 +44,8 @@
       utf16_expected[i] = ch;
     }
 
-    SirtRef<String> string(Thread::Current(), String::AllocFromModifiedUtf8(length, utf8_in));
+    Thread* self = Thread::Current();
+    SirtRef<String> string(self, String::AllocFromModifiedUtf8(self, length, utf8_in));
     ASSERT_EQ(length, string->GetLength());
     ASSERT_TRUE(string->GetCharArray() != NULL);
     ASSERT_TRUE(string->GetCharArray()->GetData() != NULL);
@@ -77,16 +78,18 @@
 
 TEST_F(ObjectTest, Clone) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ObjectArray<Object> > a1(soa.Self(), class_linker_->AllocObjectArray<Object>(256));
+  SirtRef<ObjectArray<Object> > a1(soa.Self(),
+                                   class_linker_->AllocObjectArray<Object>(soa.Self(), 256));
   size_t s1 = a1->SizeOf();
-  Object* clone = a1->Clone();
+  Object* clone = a1->Clone(soa.Self());
   EXPECT_EQ(s1, clone->SizeOf());
   EXPECT_TRUE(clone->GetClass() == a1->GetClass());
 }
 
 TEST_F(ObjectTest, AllocObjectArray) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<ObjectArray<Object> > oa(soa.Self(), class_linker_->AllocObjectArray<Object>(2));
+  SirtRef<ObjectArray<Object> > oa(soa.Self(),
+                                   class_linker_->AllocObjectArray<Object>(soa.Self(), 2));
   EXPECT_EQ(2, oa->GetLength());
   EXPECT_TRUE(oa->Get(0) == NULL);
   EXPECT_TRUE(oa->Get(1) == NULL);
@@ -119,15 +122,15 @@
 TEST_F(ObjectTest, AllocArray) {
   ScopedObjectAccess soa(Thread::Current());
   Class* c = class_linker_->FindSystemClass("[I");
-  SirtRef<Array> a(soa.Self(), Array::Alloc(c, 1));
+  SirtRef<Array> a(soa.Self(), Array::Alloc(soa.Self(), c, 1));
   ASSERT_TRUE(c == a->GetClass());
 
   c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
-  a.reset(Array::Alloc(c, 1));
+  a.reset(Array::Alloc(soa.Self(), c, 1));
   ASSERT_TRUE(c == a->GetClass());
 
   c = class_linker_->FindSystemClass("[[Ljava/lang/Object;");
-  a.reset(Array::Alloc(c, 1));
+  a.reset(Array::Alloc(soa.Self(), c, 1));
   ASSERT_TRUE(c == a->GetClass());
 }
 
@@ -136,7 +139,7 @@
   ScopedObjectAccess soa(Thread::Current());
   typedef typename ArrayT::ElementType T;
 
-  ArrayT* a = ArrayT::Alloc(2);
+  ArrayT* a = ArrayT::Alloc(soa.Self(), 2);
   EXPECT_EQ(2, a->GetLength());
   EXPECT_EQ(0, a->Get(0));
   EXPECT_EQ(0, a->Get(1));
@@ -238,7 +241,7 @@
   Object* s0 = field->GetObj(NULL);
   EXPECT_EQ(NULL, s0);
 
-  SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(0));
+  SirtRef<CharArray> char_array(soa.Self(), CharArray::Alloc(soa.Self(), 0));
   field->SetObj(NULL, char_array.get());
   EXPECT_EQ(char_array.get(), field->GetObj(NULL));
 
@@ -274,7 +277,7 @@
 
 TEST_F(ObjectTest, StringEqualsUtf8) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8("android"));
+  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
   EXPECT_TRUE(string->Equals("android"));
   EXPECT_FALSE(string->Equals("Android"));
   EXPECT_FALSE(string->Equals("ANDROID"));
@@ -282,15 +285,15 @@
   EXPECT_FALSE(string->Equals("and"));
   EXPECT_FALSE(string->Equals("androids"));
 
-  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(""));
+  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
   EXPECT_TRUE(empty->Equals(""));
   EXPECT_FALSE(empty->Equals("a"));
 }
 
 TEST_F(ObjectTest, StringEquals) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8("android"));
-  SirtRef<String> string_2(soa.Self(), String::AllocFromModifiedUtf8("android"));
+  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
+  SirtRef<String> string_2(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
   EXPECT_TRUE(string->Equals(string_2.get()));
   EXPECT_FALSE(string->Equals("Android"));
   EXPECT_FALSE(string->Equals("ANDROID"));
@@ -298,14 +301,14 @@
   EXPECT_FALSE(string->Equals("and"));
   EXPECT_FALSE(string->Equals("androids"));
 
-  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(""));
+  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
   EXPECT_TRUE(empty->Equals(""));
   EXPECT_FALSE(empty->Equals("a"));
 }
 
 TEST_F(ObjectTest, StringLength) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8("android"));
+  SirtRef<String> string(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "android"));
   EXPECT_EQ(string->GetLength(), 7);
   EXPECT_EQ(string->GetUtfLength(), 7);
 
@@ -380,9 +383,9 @@
 
 TEST_F(ObjectTest, StringHashCode) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(""));
-  SirtRef<String> A(soa.Self(), String::AllocFromModifiedUtf8("A"));
-  SirtRef<String> ABC(soa.Self(), String::AllocFromModifiedUtf8("ABC"));
+  SirtRef<String> empty(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
+  SirtRef<String> A(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "A"));
+  SirtRef<String> ABC(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
 
   EXPECT_EQ(0, empty->GetHashCode());
   EXPECT_EQ(65, A->GetHashCode());
@@ -399,8 +402,8 @@
   ASSERT_TRUE(X != NULL);
   ASSERT_TRUE(Y != NULL);
 
-  SirtRef<Object> x(soa.Self(), X->AllocObject());
-  SirtRef<Object> y(soa.Self(), Y->AllocObject());
+  SirtRef<Object> x(soa.Self(), X->AllocObject(soa.Self()));
+  SirtRef<Object> y(soa.Self(), Y->AllocObject(soa.Self()));
   ASSERT_TRUE(x.get() != NULL);
   ASSERT_TRUE(y.get() != NULL);
 
@@ -416,7 +419,7 @@
   EXPECT_TRUE(Object_array_class->InstanceOf(java_lang_Class));
 
   // All array classes implement Cloneable and Serializable.
-  Object* array = ObjectArray<Object>::Alloc(Object_array_class, 1);
+  Object* array = ObjectArray<Object>::Alloc(soa.Self(), Object_array_class, 1);
   Class* java_lang_Cloneable = class_linker_->FindSystemClass("Ljava/lang/Cloneable;");
   Class* java_io_Serializable = class_linker_->FindSystemClass("Ljava/io/Serializable;");
   EXPECT_TRUE(array->InstanceOf(java_lang_Cloneable));
@@ -515,7 +518,7 @@
 
 TEST_F(ObjectTest, FindInstanceField) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8("ABC"));
+  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
   ASSERT_TRUE(s.get() != NULL);
   Class* c = s->GetClass();
   ASSERT_TRUE(c != NULL);
@@ -548,7 +551,7 @@
 
 TEST_F(ObjectTest, FindStaticField) {
   ScopedObjectAccess soa(Thread::Current());
-  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8("ABC"));
+  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "ABC"));
   ASSERT_TRUE(s.get() != NULL);
   Class* c = s->GetClass();
   ASSERT_TRUE(c != NULL);
diff --git a/src/object_utils.h b/src/object_utils.h
index 1d66c8f..297035f 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -24,6 +24,7 @@
 #include "monitor.h"
 #include "object.h"
 #include "runtime.h"
+#include "sirt_ref.h"
 #include "UniquePtr.h"
 
 #include <string>
@@ -486,12 +487,15 @@
     return GetDexFile().GetProtoParameters(proto);
   }
 
-  ObjectArray<Class>* GetParameterTypes()
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  ObjectArray<Class>* GetParameterTypes(Thread* self)
+      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     const DexFile::TypeList* params = GetParameterTypeList();
-    Class* array_class = GetClassLinker()->FindSystemClass("[Ljava/lang/Class;");
     uint32_t num_params = params == NULL ? 0 : params->Size();
-    ObjectArray<Class>* result = ObjectArray<Class>::Alloc(array_class, num_params);
+    SirtRef<ObjectArray<Class> > result(self, GetClassLinker()->AllocClassArray(self, num_params));
+    if (UNLIKELY(result.get() == NULL)) {
+      CHECK(self->IsExceptionPending());
+      return NULL;
+    }
     for (uint32_t i = 0; i < num_params; i++) {
       Class* param_type = GetClassFromTypeIdx(params->GetTypeItem(i).type_idx_);
       if (param_type == NULL) {
@@ -500,7 +504,7 @@
       }
       result->Set(i, param_type);
     }
-    return result;
+    return result.get();
   }
 
   Class* GetReturnType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
diff --git a/src/reference_table_test.cc b/src/reference_table_test.cc
index b35110d..c400f83 100644
--- a/src/reference_table_test.cc
+++ b/src/reference_table_test.cc
@@ -25,7 +25,7 @@
 
 TEST_F(ReferenceTableTest, Basics) {
   ScopedObjectAccess soa(Thread::Current());
-  Object* o1 = String::AllocFromModifiedUtf8("hello");
+  Object* o1 = String::AllocFromModifiedUtf8(soa.Self(), "hello");
 
   ReferenceTable rt("test", 0, 11);
 
@@ -56,7 +56,7 @@
   }
 
   // Add a second object 10 times and check dumping is sane.
-  Object* o2 = ShortArray::Alloc(0);
+  Object* o2 = ShortArray::Alloc(soa.Self(), 0);
   for (size_t i = 0; i < 10; ++i) {
     rt.Add(o2);
     EXPECT_EQ(i + 2, rt.Size());
diff --git a/src/reflection.cc b/src/reflection.cc
index 7d73ae2..c793d2c 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -234,11 +234,10 @@
     LOG(FATAL) << static_cast<int>(src_class);
   }
 
-  if (kIsDebugBuild) {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    CHECK_EQ(Thread::Current()->GetState(), kRunnable);
-  }
   ScopedObjectAccessUnchecked soa(Thread::Current());
+  if (kIsDebugBuild) {
+    CHECK_EQ(soa.Self()->GetState(), kRunnable);
+  }
   JValue args[1] = { value };
   soa.DecodeMethod(m)->Invoke(soa.Self(), NULL, args, &value);
 }
diff --git a/src/runtime.cc b/src/runtime.cc
index d10c351..3444f78 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -187,7 +187,7 @@
 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(*Locks::abort_lock_);
+  MutexLock mu(Thread::Current(), *Locks::abort_lock_);
 
   // Get any pending output out of the way.
   fflush(NULL);
@@ -661,10 +661,7 @@
   Thread* self = Thread::Current();
 
   // Must be in the kNative state for calling native methods.
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    CHECK_EQ(self->GetState(), kNative);
-  }
+  CHECK_EQ(self->GetState(), kNative);
 
   JNIEnv* env = self->GetJniEnv();
   env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons, WellKnownClasses::java_lang_Daemons_start);
@@ -762,10 +759,7 @@
   JNIEnv* env = self->GetJniEnv();
 
   // Must be in the kNative state for calling native methods (JNI_OnLoad code).
-  {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);
-    CHECK_EQ(self->GetState(), kNative);
-  }
+  CHECK_EQ(self->GetState(), kNative);
 
   // First set up JniConstants, which is used by both the runtime's built-in native
   // methods and libcore.
@@ -984,8 +978,8 @@
 
 AbstractMethod* Runtime::CreateResolutionMethod() {
   Class* method_class = AbstractMethod::GetMethodClass();
-  SirtRef<AbstractMethod> method(Thread::Current(),
-                                 down_cast<AbstractMethod*>(method_class->AllocObject()));
+  Thread* self = Thread::Current();
+  SirtRef<AbstractMethod> method(self, down_cast<AbstractMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for resolution method saves
   method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -998,8 +992,8 @@
 AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set,
                                                 CalleeSaveType type) {
   Class* method_class = AbstractMethod::GetMethodClass();
-  SirtRef<AbstractMethod>
-      method(Thread::Current(), down_cast<AbstractMethod*>(method_class->AllocObject()));
+  Thread* self = Thread::Current();
+  SirtRef<AbstractMethod> method(self, down_cast<AbstractMethod*>(method_class->AllocObject(self)));
   method->SetDeclaringClass(method_class);
   // TODO: use a special method for callee saves
   method->SetDexMethodIndex(DexFile::kDexNoIndex16);
diff --git a/src/runtime_linux.cc b/src/runtime_linux.cc
index 85eeb8f..01c08d3 100644
--- a/src/runtime_linux.cc
+++ b/src/runtime_linux.cc
@@ -23,6 +23,7 @@
 #include "logging.h"
 #include "mutex.h"
 #include "stringprintf.h"
+#include "thread.h"
 #include "utils.h"
 
 namespace art {
@@ -227,7 +228,7 @@
 };
 
 static void HandleUnexpectedSignal(int signal_number, siginfo_t* info, void* raw_context) {
-  MutexLock mu(*Locks::unexpected_signal_lock_);
+  MutexLock mu(Thread::Current(), *Locks::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 4af6fe5..54baa42 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -100,19 +100,19 @@
   if (UNLIKELY(klass == NULL)) {  // Not in dex cache so try to resolve
     klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
     if (klass == NULL) {  // Error
-      DCHECK(Thread::Current()->IsExceptionPending());
+      DCHECK(self->IsExceptionPending());
       return NULL;  // Failure
     }
   }
   if (UNLIKELY(klass->IsPrimitive() && !klass->IsPrimitiveInt())) {
     if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
-      Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
-                                            "Bad filled array request for type %s",
-                                            PrettyDescriptor(klass).c_str());
+      self->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
+                               "Bad filled array request for type %s",
+                                PrettyDescriptor(klass).c_str());
     } else {
-      Thread::Current()->ThrowNewExceptionF("Ljava/lang/InternalError;",
-                                            "Found type %s; filled-new-array not implemented for anything but \'int\'",
-                                            PrettyDescriptor(klass).c_str());
+      self->ThrowNewExceptionF("Ljava/lang/InternalError;",
+                               "Found type %s; filled-new-array not implemented for anything but \'int\'",
+                               PrettyDescriptor(klass).c_str());
     }
     return NULL;  // Failure
   } else {
@@ -124,7 +124,7 @@
       }
     }
     DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
-    return Array::Alloc(klass, component_count);
+    return Array::Alloc(self, klass, component_count);
   }
 }
 
diff --git a/src/runtime_support.h b/src/runtime_support.h
index eff50b3..0d24e48 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -78,7 +78,7 @@
     DCHECK(self->IsExceptionPending());
     return NULL;  // Failure
   }
-  return klass->AllocObject();
+  return klass->AllocObject(self);
 }
 
 // Given the context of a calling Method, use its DexCache to resolve a type to an array Class. If
@@ -86,11 +86,10 @@
 // When verification/compiler hasn't been able to verify access, optionally perform an access
 // check.
 static inline Array* AllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
-                                        bool access_check)
+                                        Thread* self, bool access_check)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (UNLIKELY(component_count < 0)) {
-    Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d",
-                                          component_count);
+    self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
     return NULL;  // Failure
   }
   Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
@@ -109,7 +108,7 @@
       return NULL;  // Failure
     }
   }
-  return Array::Alloc(klass, component_count);
+  return Array::Alloc(self, klass, component_count);
 }
 
 extern Array* CheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
diff --git a/src/scoped_thread_state_change.h b/src/scoped_thread_state_change.h
index 9da41e0..32c3685 100644
--- a/src/scoped_thread_state_change.h
+++ b/src/scoped_thread_state_change.h
@@ -35,7 +35,7 @@
     if (self_ == NULL) {
       // Value chosen arbitrarily and won't be used in the destructor since thread_ == NULL.
       old_thread_state_ = kTerminated;
-      MutexLock mu(*Locks::runtime_shutdown_lock_);
+      MutexLock mu(NULL, *Locks::runtime_shutdown_lock_);
       Runtime* runtime = Runtime::Current();
       CHECK(runtime == NULL || !runtime->IsStarted() || runtime->IsShuttingDown());
     } else {
@@ -63,7 +63,7 @@
   ~ScopedThreadStateChange() LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_) {
     if (self_ == NULL) {
       if (!expected_has_no_thread_) {
-        MutexLock mu(*Locks::runtime_shutdown_lock_);
+        MutexLock mu(NULL, *Locks::runtime_shutdown_lock_);
         Runtime* runtime = Runtime::Current();
         bool shutting_down = (runtime == NULL) || runtime->IsShuttingDown();
         CHECK(shutting_down);
diff --git a/src/signal_catcher.cc b/src/signal_catcher.cc
index 8376bb6..b6f6a41 100644
--- a/src/signal_catcher.cc
+++ b/src/signal_catcher.cc
@@ -85,12 +85,12 @@
 }
 
 void SignalCatcher::SetHaltFlag(bool new_value) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   halt_ = new_value;
 }
 
 bool SignalCatcher::ShouldHalt() {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   return halt_;
 }
 
diff --git a/src/space.cc b/src/space.cc
index 58476ad..c1f4384 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -208,13 +208,13 @@
   return result;
 }
 
-Object* AllocSpace::AllocWithoutGrowth(size_t num_bytes) {
-  MutexLock mu(lock_);
+Object* AllocSpace::AllocWithoutGrowth(Thread* self, size_t num_bytes) {
+  MutexLock mu(self, lock_);
   return AllocWithoutGrowthLocked(num_bytes);
 }
 
-Object* AllocSpace::AllocWithGrowth(size_t num_bytes) {
-  MutexLock mu(lock_);
+Object* AllocSpace::AllocWithGrowth(Thread* self, size_t num_bytes) {
+  MutexLock mu(self, lock_);
   // Grow as much as possible within the mspace.
   size_t max_allowed = Capacity();
   mspace_set_footprint_limit(mspace_, max_allowed);
@@ -284,8 +284,8 @@
   return alloc_space;
 }
 
-void AllocSpace::Free(Object* ptr) {
-  MutexLock mu(lock_);
+void AllocSpace::Free(Thread* self, Object* ptr) {
+  MutexLock mu(self, lock_);
   if (kDebugSpaces) {
     CHECK(ptr != NULL);
     CHECK(Contains(ptr)) << "Free (" << ptr << ") not in bounds of heap " << *this;
@@ -298,8 +298,8 @@
   mspace_free(mspace_, ptr);
 }
 
-void AllocSpace::FreeList(size_t num_ptrs, Object** ptrs) {
-  MutexLock mu(lock_);
+void AllocSpace::FreeList(Thread* self, size_t num_ptrs, Object** ptrs) {
+  MutexLock mu(self, lock_);
   if (kDebugSpaces) {
     CHECK(ptrs != NULL);
     size_t num_broken_ptrs = 0;
@@ -329,7 +329,7 @@
 }
 
 void* AllocSpace::MoreCore(intptr_t increment) {
-  lock_.AssertHeld();
+  lock_.AssertHeld(Thread::Current());
   byte* original_end = end_;
   if (increment != 0) {
     VLOG(heap) << "AllocSpace::MoreCore " << PrettySize(increment);
@@ -382,7 +382,7 @@
 }
 
 void AllocSpace::Trim() {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), 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.
@@ -391,18 +391,18 @@
 
 void AllocSpace::Walk(void(*callback)(void *start, void *end, size_t num_bytes, void* callback_arg),
                       void* arg) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   mspace_inspect_all(mspace_, callback, arg);
   callback(NULL, NULL, 0, arg);  // Indicate end of a space.
 }
 
 size_t AllocSpace::GetFootprintLimit() {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   return mspace_footprint_limit(mspace_);
 }
 
 void AllocSpace::SetFootprintLimit(size_t new_size) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), 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.
@@ -575,12 +575,12 @@
   return new LargeObjectMapSpace(name);
 }
 
-Object* LargeObjectMapSpace::Alloc(size_t num_bytes) {
-  MutexLock mu(lock_);
+Object* LargeObjectMapSpace::Alloc(Thread* self, size_t num_bytes) {
   MemMap* mem_map = MemMap::MapAnonymous("allocation", NULL, num_bytes, PROT_READ | PROT_WRITE);
   if (mem_map == NULL) {
     return NULL;
   }
+  MutexLock mu(self, lock_);
   Object* obj = reinterpret_cast<Object*>(mem_map->Begin());
   large_objects_.push_back(obj);
   mem_maps_.Put(obj, mem_map);
@@ -589,8 +589,8 @@
   return obj;
 }
 
-void LargeObjectMapSpace::Free(Object* ptr) {
-  MutexLock mu(lock_);
+void LargeObjectMapSpace::Free(Thread* self, Object* ptr) {
+  MutexLock mu(self, lock_);
   MemMaps::iterator found = mem_maps_.find(ptr);
   CHECK(found != mem_maps_.end()) << "Attempted to free large object which was not live";
   DCHECK_GE(num_bytes_allocated_, found->second->Size());
@@ -601,14 +601,14 @@
 }
 
 size_t LargeObjectMapSpace::AllocationSize(const Object* obj) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   MemMaps::iterator found = mem_maps_.find(const_cast<Object*>(obj));
   CHECK(found != mem_maps_.end()) << "Attempted to get size of a large object which is not live";
   return found->second->Size();
 }
 
 void LargeObjectMapSpace::Walk(AllocSpace::WalkCallback callback, void* arg) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   for (MemMaps::iterator it = mem_maps_.begin(); it != mem_maps_.end(); ++it) {
     MemMap* mem_map = it->second;
     callback(mem_map->Begin(), mem_map->End(), mem_map->Size(), arg);
@@ -617,7 +617,7 @@
 }
 
 bool LargeObjectMapSpace::Contains(const Object* obj) const {
-  MutexLock mu(const_cast<Mutex&>(lock_));
+  MutexLock mu(Thread::Current(), lock_);
   return mem_maps_.find(const_cast<Object*>(obj)) != mem_maps_.end();
 }
 
@@ -679,7 +679,7 @@
 }
 
 void FreeListSpace::Walk(AllocSpace::WalkCallback callback, void* arg) {
-  MutexLock mu(lock_);
+  MutexLock mu(Thread::Current(), lock_);
   for (Chunk* chunk = &chunks_.front(); chunk < &chunks_.back(); ) {
     if (!chunk->IsFree()) {
       size_t size = chunk->GetSize();
@@ -692,8 +692,8 @@
   }
 }
 
-void FreeListSpace::Free(Object* obj) {
-  MutexLock mu(lock_);
+void FreeListSpace::Free(Thread* self, Object* obj) {
+  MutexLock mu(self, lock_);
   CHECK(Contains(obj));
   // Check adjacent chunks to see if we need to combine.
   Chunk* chunk = ChunkFromAddr(obj);
@@ -734,8 +734,8 @@
   return chunk->GetSize();
 }
 
-Object* FreeListSpace::Alloc(size_t num_bytes) {
-  MutexLock mu(lock_);
+Object* FreeListSpace::Alloc(Thread* self, size_t num_bytes) {
+  MutexLock mu(self, lock_);
   num_bytes = RoundUp(num_bytes, kAlignment);
   Chunk temp;
   temp.SetSize(num_bytes);
@@ -762,9 +762,9 @@
   return reinterpret_cast<Object*>(addr);
 }
 
-void FreeListSpace::FreeList(size_t num_ptrs, Object** ptrs) {
+void FreeListSpace::FreeList(Thread* self, size_t num_ptrs, Object** ptrs) {
   for (size_t i = 0; i < num_ptrs; ++i) {
-    Free(ptrs[i]);
+    Free(self, ptrs[i]);
   }
 }
 
diff --git a/src/space.h b/src/space.h
index 12682f9..af6ab3b 100644
--- a/src/space.h
+++ b/src/space.h
@@ -241,15 +241,15 @@
                             size_t capacity, byte* requested_begin);
 
   // Allocate num_bytes without allowing the underlying mspace to grow.
-  virtual Object* AllocWithGrowth(size_t num_bytes);
+  virtual Object* AllocWithGrowth(Thread* self, size_t num_bytes);
 
   // Allocate num_bytes allowing the underlying mspace to grow.
-  virtual Object* AllocWithoutGrowth(size_t num_bytes);
+  virtual Object* AllocWithoutGrowth(Thread* self, size_t num_bytes);
 
   // Return the storage space required by obj.
   virtual size_t AllocationSize(const Object* obj);
-  virtual void Free(Object* ptr);
-  virtual void FreeList(size_t num_ptrs, Object** ptrs);
+  virtual void Free(Thread* self, Object* ptr);
+  virtual void FreeList(Thread* self, size_t num_ptrs, Object** ptrs);
 
   void* MoreCore(intptr_t increment);
 
@@ -435,8 +435,8 @@
 
   // Return the storage space required by obj.
   virtual size_t AllocationSize(const Object* obj) = 0;
-  virtual Object* Alloc(size_t num_bytes) = 0;
-  virtual void Free(Object* ptr) = 0;
+  virtual Object* Alloc(Thread* self, size_t num_bytes) = 0;
+  virtual void Free(Thread* self, Object* ptr) = 0;
   virtual void Walk(AllocSpace::WalkCallback, void* arg) = 0;
 
   virtual ~LargeObjectSpace() {}
@@ -472,8 +472,8 @@
 
   // Return the storage space required by obj.
   virtual size_t AllocationSize(const Object* obj);
-  virtual Object* Alloc(size_t num_bytes);
-  virtual void Free(Object* ptr);
+  virtual Object* Alloc(Thread* self, size_t num_bytes);
+  virtual void Free(Thread* self, Object* ptr);
   virtual void Walk(AllocSpace::WalkCallback, void* arg);
   virtual bool Contains(const Object* obj) const;
 private:
@@ -481,7 +481,7 @@
   virtual ~LargeObjectMapSpace() {}
 
   // Used to ensure mutual exclusion when the allocation spaces data structures are being modified.
-  Mutex lock_;
+  mutable Mutex lock_;
   std::vector<Object*> large_objects_;
   typedef SafeMap<Object*, MemMap*> MemMaps;
   MemMaps mem_maps_;
@@ -493,9 +493,9 @@
   static FreeListSpace* Create(const std::string& name, byte* requested_begin, size_t capacity);
 
   virtual size_t AllocationSize(const Object* obj);
-  virtual Object* Alloc(size_t num_bytes);
-  virtual void Free(Object* obj);
-  virtual void FreeList(size_t num_ptrs, Object** ptrs);
+  virtual Object* Alloc(Thread* self, size_t num_bytes);
+  virtual void Free(Thread* self, Object* obj);
+  virtual void FreeList(Thread* self, size_t num_ptrs, Object** ptrs);
   virtual bool Contains(const Object* obj) const;
   virtual void Walk(AllocSpace::WalkCallback callback, void* arg);
 
diff --git a/src/space_test.cc b/src/space_test.cc
index e9c45c4..0319147 100644
--- a/src/space_test.cc
+++ b/src/space_test.cc
@@ -80,106 +80,108 @@
 
     // Make space findable to the heap, will also delete space when runtime is cleaned up
     Runtime::Current()->GetHeap()->AddSpace(space);
+    Thread* self = Thread::Current();
 
     // Succeeds, fits without adjusting the footprint limit.
-    Object* ptr1 = space->AllocWithoutGrowth(1 * MB);
+    Object* ptr1 = space->AllocWithoutGrowth(self, 1 * MB);
     EXPECT_TRUE(ptr1 != NULL);
 
     // Fails, requires a higher footprint limit.
-    Object* ptr2 = space->AllocWithoutGrowth(8 * MB);
+    Object* ptr2 = space->AllocWithoutGrowth(self, 8 * MB);
     EXPECT_TRUE(ptr2 == NULL);
 
     // Succeeds, adjusts the footprint.
-    Object* ptr3 = space->AllocWithGrowth(8 * MB);
+    Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
     EXPECT_TRUE(ptr3 != NULL);
 
     // Fails, requires a higher footprint limit.
-    Object* ptr4 = space->AllocWithoutGrowth(8 * MB);
+    Object* ptr4 = space->AllocWithoutGrowth(self, 8 * MB);
     EXPECT_TRUE(ptr4 == NULL);
 
     // Also fails, requires a higher allowed footprint.
-    Object* ptr5 = space->AllocWithGrowth(8 * MB);
+    Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
     EXPECT_TRUE(ptr5 == NULL);
 
     // Release some memory.
     size_t free3 = space->AllocationSize(ptr3);
-    space->Free(ptr3);
+    space->Free(self, ptr3);
     EXPECT_LE(8U * MB, free3);
 
     // Succeeds, now that memory has been freed.
-    void* ptr6 = space->AllocWithGrowth(9 * MB);
+    void* ptr6 = space->AllocWithGrowth(self, 9 * MB);
     EXPECT_TRUE(ptr6 != NULL);
 
     // Final clean up.
     size_t free1 = space->AllocationSize(ptr1);
-    space->Free(ptr1);
+    space->Free(self, ptr1);
     EXPECT_LE(1U * MB, free1);
 
     // Make sure that the zygote space isn't directly at the start of the space.
-    space->AllocWithoutGrowth(1U * MB);
+    space->AllocWithoutGrowth(self, 1U * MB);
     space = space->CreateZygoteSpace();
 
     // Make space findable to the heap, will also delete space when runtime is cleaned up
     Runtime::Current()->GetHeap()->AddSpace(space);
 
     // Succeeds, fits without adjusting the footprint limit.
-    ptr1 = space->AllocWithoutGrowth(1 * MB);
+    ptr1 = space->AllocWithoutGrowth(self, 1 * MB);
     EXPECT_TRUE(ptr1 != NULL);
 
     // Fails, requires a higher footprint limit.
-    ptr2 = space->AllocWithoutGrowth(8 * MB);
+    ptr2 = space->AllocWithoutGrowth(self, 8 * MB);
     EXPECT_TRUE(ptr2 == NULL);
 
     // Succeeds, adjusts the footprint.
-    ptr3 = space->AllocWithGrowth(2 * MB);
+    ptr3 = space->AllocWithGrowth(self, 2 * MB);
     EXPECT_TRUE(ptr3 != NULL);
-    space->Free(ptr3);
+    space->Free(self, ptr3);
 
     // Final clean up.
     free1 = space->AllocationSize(ptr1);
-    space->Free(ptr1);
+    space->Free(self, ptr1);
     EXPECT_LE(1U * MB, free1);
 }
 
 TEST_F(SpaceTest, AllocAndFree) {
   AllocSpace* space(AllocSpace::Create("test", 4 * MB, 16 * MB, 16 * MB, NULL));
   ASSERT_TRUE(space != NULL);
+  Thread* self = Thread::Current();
 
   // Make space findable to the heap, will also delete space when runtime is cleaned up
   Runtime::Current()->GetHeap()->AddSpace(space);
 
   // Succeeds, fits without adjusting the footprint limit.
-  Object* ptr1 = space->AllocWithoutGrowth(1 * MB);
+  Object* ptr1 = space->AllocWithoutGrowth(self, 1 * MB);
   EXPECT_TRUE(ptr1 != NULL);
 
   // Fails, requires a higher footprint limit.
-  Object* ptr2 = space->AllocWithoutGrowth(8 * MB);
+  Object* ptr2 = space->AllocWithoutGrowth(self, 8 * MB);
   EXPECT_TRUE(ptr2 == NULL);
 
   // Succeeds, adjusts the footprint.
-  Object* ptr3 = space->AllocWithGrowth(8 * MB);
+  Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
   EXPECT_TRUE(ptr3 != NULL);
 
   // Fails, requires a higher footprint limit.
-  Object* ptr4 = space->AllocWithoutGrowth(8 * MB);
+  Object* ptr4 = space->AllocWithoutGrowth(self, 8 * MB);
   EXPECT_TRUE(ptr4 == NULL);
 
   // Also fails, requires a higher allowed footprint.
-  Object* ptr5 = space->AllocWithGrowth(8 * MB);
+  Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
   EXPECT_TRUE(ptr5 == NULL);
 
   // Release some memory.
   size_t free3 = space->AllocationSize(ptr3);
-  space->Free(ptr3);
+  space->Free(self, ptr3);
   EXPECT_LE(8U * MB, free3);
 
   // Succeeds, now that memory has been freed.
-  void* ptr6 = space->AllocWithGrowth(9 * MB);
+  void* ptr6 = space->AllocWithGrowth(self, 9 * MB);
   EXPECT_TRUE(ptr6 != NULL);
 
   // Final clean up.
   size_t free1 = space->AllocationSize(ptr1);
-  space->Free(ptr1);
+  space->Free(self, ptr1);
   EXPECT_LE(1U * MB, free1);
 }
 
@@ -189,28 +191,29 @@
 
   // Make space findable to the heap, will also delete space when runtime is cleaned up
   Runtime::Current()->GetHeap()->AddSpace(space);
+  Thread* self = Thread::Current();
 
   // Succeeds, fits without adjusting the max allowed footprint.
   Object* lots_of_objects[1024];
   for (size_t i = 0; i < arraysize(lots_of_objects); i++) {
-    lots_of_objects[i] = space->AllocWithoutGrowth(16);
+    lots_of_objects[i] = space->AllocWithoutGrowth(self, 16);
     EXPECT_TRUE(lots_of_objects[i] != NULL);
   }
 
   // Release memory and check pointers are NULL
-  space->FreeList(arraysize(lots_of_objects), lots_of_objects);
+  space->FreeList(self, arraysize(lots_of_objects), lots_of_objects);
   for (size_t i = 0; i < arraysize(lots_of_objects); i++) {
     EXPECT_TRUE(lots_of_objects[i] == NULL);
   }
 
   // Succeeds, fits by adjusting the max allowed footprint.
   for (size_t i = 0; i < arraysize(lots_of_objects); i++) {
-    lots_of_objects[i] = space->AllocWithGrowth(1024);
+    lots_of_objects[i] = space->AllocWithGrowth(self, 1024);
     EXPECT_TRUE(lots_of_objects[i] != NULL);
   }
 
   // Release memory and check pointers are NULL
-  space->FreeList(arraysize(lots_of_objects), lots_of_objects);
+  space->FreeList(self, arraysize(lots_of_objects), lots_of_objects);
   for (size_t i = 0; i < arraysize(lots_of_objects); i++) {
     EXPECT_TRUE(lots_of_objects[i] == NULL);
   }
@@ -252,6 +255,7 @@
   UniquePtr<Object*[]> lots_of_objects(new Object*[max_objects]);
   size_t last_object = 0;  // last object for which allocation succeeded
   size_t amount_allocated = 0;  // amount of space allocated
+  Thread* self = Thread::Current();
   for (size_t i = 0; i < max_objects; i++) {
     size_t alloc_fails = 0;  // number of failed allocations
     size_t max_fails = 30;  // number of times we fail allocation before giving up
@@ -267,9 +271,9 @@
       }
       Object* object;
       if (round <= 1) {
-        object = space->AllocWithoutGrowth(alloc_size);
+        object = space->AllocWithoutGrowth(self, alloc_size);
       } else {
-        object = space->AllocWithGrowth(alloc_size);
+        object = space->AllocWithGrowth(self, alloc_size);
       }
       footprint = mspace_footprint(mspace);
       EXPECT_GE(space->Size(), footprint);  // invariant
@@ -332,7 +336,7 @@
       } else {
         EXPECT_GE(allocation_size, 8u);
       }
-      space->Free(object);
+      space->Free(self, object);
       lots_of_objects.get()[i] = NULL;
       amount_allocated -= allocation_size;
       footprint = mspace_footprint(mspace);
@@ -346,9 +350,9 @@
   Object* large_object;
   size_t three_quarters_space = (growth_limit / 2) + (growth_limit / 4);
   if (round <= 1) {
-    large_object = space->AllocWithoutGrowth(three_quarters_space);
+    large_object = space->AllocWithoutGrowth(self, three_quarters_space);
   } else {
-    large_object = space->AllocWithGrowth(three_quarters_space);
+    large_object = space->AllocWithGrowth(self, three_quarters_space);
   }
   EXPECT_TRUE(large_object != NULL);
 
@@ -359,7 +363,7 @@
   EXPECT_LE(space->Size(), growth_limit);
 
   // Clean up
-  space->Free(large_object);
+  space->Free(self, large_object);
 
   // Sanity check footprint
   footprint = mspace_footprint(mspace);
diff --git a/src/thread.cc b/src/thread.cc
index ba8763c..a63a5aa 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -110,7 +110,9 @@
     return NULL;
   }
   {
-    MutexLock mu(*Locks::runtime_shutdown_lock_);
+    // TODO: pass self to MutexLock - requires self to equal Thread::Current(), which is only true
+    //       after self->Init().
+    MutexLock mu(NULL, *Locks::runtime_shutdown_lock_);
     // Check that if we got here we cannot be shutting down (as shutdown should never have started
     // while threads are being born).
     CHECK(!runtime->IsShuttingDown());
@@ -719,7 +721,6 @@
     if (is_daemon) {
       os << " daemon";
     }
-    MutexLock mu(self, *Locks::thread_suspend_count_lock_);
     os << " prio=" << priority
        << " tid=" << thread->GetThinLockId()
        << " " << thread->GetState() << "\n";
@@ -874,7 +875,7 @@
 
 void Thread::Startup() {
   {
-    MutexLock mu(*Locks::thread_suspend_count_lock_);  // Keep GCC happy.
+    MutexLock mu(Thread::Current(), *Locks::thread_suspend_count_lock_);  // Keep GCC happy.
     resume_cond_ = new ConditionVariable("Thread resumption condition variable");
   }
 
@@ -1166,7 +1167,7 @@
 
 // Implements java.lang.Thread.interrupted.
 bool Thread::Interrupted() {
-  MutexLock mu(*wait_mutex_);
+  MutexLock mu(Thread::Current(), *wait_mutex_);
   bool interrupted = interrupted_;
   interrupted_ = false;
   return interrupted;
@@ -1174,12 +1175,12 @@
 
 // Implements java.lang.Thread.isInterrupted.
 bool Thread::IsInterrupted() {
-  MutexLock mu(*wait_mutex_);
+  MutexLock mu(Thread::Current(), *wait_mutex_);
   return interrupted_;
 }
 
 void Thread::Interrupt() {
-  MutexLock mu(*wait_mutex_);
+  MutexLock mu(Thread::Current(), *wait_mutex_);
   if (interrupted_) {
     return;
   }
@@ -1188,7 +1189,7 @@
 }
 
 void Thread::Notify() {
-  MutexLock mu(*wait_mutex_);
+  MutexLock mu(Thread::Current(), *wait_mutex_);
   NotifyLocked();
 }
 
@@ -1252,11 +1253,12 @@
     // Allocate method trace with an extra slot that will hold the PC trace
     SirtRef<ObjectArray<Object> >
         method_trace(self_,
-                     Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1));
+                     Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(self_,
+                                                                                    depth + 1));
     if (method_trace.get() == NULL) {
       return false;
     }
-    IntArray* dex_pc_trace = IntArray::Alloc(depth);
+    IntArray* dex_pc_trace = IntArray::Alloc(self_, depth);
     if (dex_pc_trace == NULL) {
       return false;
     }
@@ -1350,7 +1352,7 @@
     depth = std::min(depth, java_traces->GetLength());
   } else {
     // Create java_trace array and place in local reference table
-    java_traces = class_linker->AllocStackTraceElementArray(depth);
+    java_traces = class_linker->AllocStackTraceElementArray(soa.Self(), depth);
     if (java_traces == NULL) {
       return NULL;
     }
@@ -1374,19 +1376,23 @@
     CHECK(descriptor != NULL);
     std::string class_name(PrettyDescriptor(descriptor));
     SirtRef<String> class_name_object(soa.Self(),
-                                      String::AllocFromModifiedUtf8(class_name.c_str()));
+                                      String::AllocFromModifiedUtf8(soa.Self(),
+                                                                    class_name.c_str()));
     if (class_name_object.get() == NULL) {
       return NULL;
     }
     const char* method_name = mh.GetName();
     CHECK(method_name != NULL);
-    SirtRef<String> method_name_object(soa.Self(), String::AllocFromModifiedUtf8(method_name));
+    SirtRef<String> method_name_object(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(),
+                                                                                 method_name));
     if (method_name_object.get() == NULL) {
       return NULL;
     }
     const char* source_file = mh.GetDeclaringClassSourceFile();
-    SirtRef<String> source_name_object(soa.Self(), String::AllocFromModifiedUtf8(source_file));
-    StackTraceElement* obj = StackTraceElement::Alloc(class_name_object.get(),
+    SirtRef<String> source_name_object(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(),
+                                                                                 source_file));
+    StackTraceElement* obj = StackTraceElement::Alloc(soa.Self(),
+                                                      class_name_object.get(),
                                                       method_name_object.get(),
                                                       source_name_object.get(),
                                                       line_number);
@@ -1450,7 +1456,7 @@
     if (exception.get() != NULL) {
       ScopedObjectAccessUnchecked soa(env);
       Throwable* t = reinterpret_cast<Throwable*>(soa.Self()->DecodeJObject(exception.get()));
-      t->SetDetailMessage(String::AllocFromModifiedUtf8(msg));
+      t->SetDetailMessage(String::AllocFromModifiedUtf8(soa.Self(), msg));
       soa.Self()->SetException(t);
     } else {
       LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI AllocObject failed: "
diff --git a/src/thread_list.cc b/src/thread_list.cc
index 83f2658..4030be6 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -66,7 +66,7 @@
 
 void ThreadList::DumpForSigQuit(std::ostream& os) {
   {
-    MutexLock mu(*Locks::thread_list_lock_);
+    MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
     DumpLocked(os);
   }
   DumpUnattachedThreads(os);
@@ -91,13 +91,14 @@
 
   dirent de;
   dirent* e;
+  Thread* self = Thread::Current();
   while (!readdir_r(d, &de, &e) && e != NULL) {
     char* end;
     pid_t tid = strtol(de.d_name, &end, 10);
     if (!*end) {
       bool contains;
       {
-        MutexLock mu(*Locks::thread_list_lock_);
+        MutexLock mu(self, *Locks::thread_list_lock_);
         contains = Contains(tid);
       }
       if (!contains) {
@@ -109,7 +110,7 @@
 }
 
 void ThreadList::DumpLocked(std::ostream& os) {
-  Locks::thread_list_lock_->AssertHeld();
+  Locks::thread_list_lock_->AssertHeld(Thread::Current());
   os << "DALVIK THREADS (" << list_.size() << "):\n";
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     (*it)->Dump(os);
@@ -117,9 +118,9 @@
   }
 }
 
-void ThreadList::AssertThreadsAreSuspended(Thread* ignore1, Thread* ignore2) {
-  MutexLock mu(*Locks::thread_list_lock_);
-  MutexLock mu2(*Locks::thread_suspend_count_lock_);
+void ThreadList::AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2) {
+  MutexLock mu(self, *Locks::thread_list_lock_);
+  MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     Thread* thread = *it;
     if (thread != ignore1 || thread == ignore2) {
@@ -194,7 +195,7 @@
 #endif
 
   // Debug check that all threads are suspended.
-  AssertThreadsAreSuspended(self);
+  AssertThreadsAreSuspended(self, self);
 
   VLOG(threads) << *self << " SuspendAll complete";
 }
@@ -205,7 +206,7 @@
   VLOG(threads) << *self << " ResumeAll starting";
 
   // Debug check that all threads are suspended.
-  AssertThreadsAreSuspended(self);
+  AssertThreadsAreSuspended(self, self);
 
   Locks::mutator_lock_->ExclusiveUnlock(self);
   {
@@ -297,7 +298,7 @@
   Locks::mutator_lock_->ExclusiveLock(self);
   Locks::mutator_lock_->ExclusiveUnlock(self);
 #endif
-  AssertThreadsAreSuspended(self, debug_thread);
+  AssertThreadsAreSuspended(self, self, debug_thread);
 
   VLOG(threads) << *self << " SuspendAll complete";
 }
@@ -422,7 +423,6 @@
     bool all_suspended = true;
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
-      MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
       if (thread != self && thread->GetState() == kRunnable) {
         if (!have_complained) {
           LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
diff --git a/src/thread_list.h b/src/thread_list.h
index b5546e3..94e987f 100644
--- a/src/thread_list.h
+++ b/src/thread_list.h
@@ -105,7 +105,7 @@
       LOCKS_EXCLUDED(Locks::thread_list_lock_,
                      Locks::thread_suspend_count_lock_);
 
-  void AssertThreadsAreSuspended(Thread* ignore1, Thread* ignore2 = NULL)
+  void AssertThreadsAreSuspended(Thread* self, Thread* ignore1, Thread* ignore2 = NULL)
       LOCKS_EXCLUDED(Locks::thread_list_lock_,
                      Locks::thread_suspend_count_lock_);
 
diff --git a/src/thread_x86.cc b/src/thread_x86.cc
index 6a72286..c841235 100644
--- a/src/thread_x86.cc
+++ b/src/thread_x86.cc
@@ -21,6 +21,7 @@
 
 #include "asm_support.h"
 #include "macros.h"
+#include "thread.h"
 #include "thread_list.h"
 
 #if defined(__APPLE__)
@@ -41,7 +42,7 @@
 
 void Thread::InitCpu() {
   static Mutex modify_ldt_lock("modify_ldt lock");
-  MutexLock mu(modify_ldt_lock);
+  MutexLock mu(Thread::Current(), modify_ldt_lock);
 
   const uintptr_t base = reinterpret_cast<uintptr_t>(this);
   const size_t limit = kPageSize;
diff --git a/src/utils_test.cc b/src/utils_test.cc
index 1fcb4b3..f1983be 100644
--- a/src/utils_test.cc
+++ b/src/utils_test.cc
@@ -89,15 +89,15 @@
   ScopedObjectAccess soa(Thread::Current());
   EXPECT_EQ("null", PrettyTypeOf(NULL));
 
-  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(""));
+  SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
   EXPECT_EQ("java.lang.String", PrettyTypeOf(s.get()));
 
-  SirtRef<ShortArray> a(soa.Self(), ShortArray::Alloc(2));
+  SirtRef<ShortArray> a(soa.Self(), ShortArray::Alloc(soa.Self(), 2));
   EXPECT_EQ("short[]", PrettyTypeOf(a.get()));
 
   Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
-  Object* o = ObjectArray<String>::Alloc(c, 0);
+  Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
   EXPECT_EQ("java.lang.String[]", PrettyTypeOf(o));
   EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyTypeOf(o->GetClass()));
 }
@@ -107,7 +107,7 @@
   EXPECT_EQ("null", PrettyClass(NULL));
   Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
-  Object* o = ObjectArray<String>::Alloc(c, 0);
+  Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
   EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyClass(o->GetClass()));
 }
 
@@ -116,7 +116,7 @@
   EXPECT_EQ("null", PrettyClassAndClassLoader(NULL));
   Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
   ASSERT_TRUE(c != NULL);
-  Object* o = ObjectArray<String>::Alloc(c, 0);
+  Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
   EXPECT_EQ("java.lang.Class<java.lang.String[],null>", PrettyClassAndClassLoader(o->GetClass()));
 }
 
diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index dd9aa8b..ad238b8 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -3229,7 +3229,7 @@
 
 void MethodVerifier::SetDexGcMap(Compiler::MethodReference ref, const std::vector<uint8_t>& gc_map) {
   {
-    MutexLock mu(*dex_gc_maps_lock_);
+    MutexLock mu(Thread::Current(), *dex_gc_maps_lock_);
     DexGcMapTable::iterator it = dex_gc_maps_->find(ref);
     if (it != dex_gc_maps_->end()) {
       delete it->second;
@@ -3241,7 +3241,7 @@
 }
 
 const std::vector<uint8_t>* MethodVerifier::GetDexGcMap(Compiler::MethodReference ref) {
-  MutexLock mu(*dex_gc_maps_lock_);
+  MutexLock mu(Thread::Current(), *dex_gc_maps_lock_);
   DexGcMapTable::const_iterator it = dex_gc_maps_->find(ref);
   if (it == dex_gc_maps_->end()) {
     return NULL;
@@ -3263,29 +3263,31 @@
 
 void MethodVerifier::Init() {
   dex_gc_maps_lock_ = new Mutex("verifier GC maps lock");
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(*dex_gc_maps_lock_);
+    MutexLock mu(self, *dex_gc_maps_lock_);
     dex_gc_maps_ = new MethodVerifier::DexGcMapTable;
   }
 
   rejected_classes_lock_ = new Mutex("verifier rejected classes lock");
   {
-    MutexLock mu(*rejected_classes_lock_);
+    MutexLock mu(self, *rejected_classes_lock_);
     rejected_classes_ = new MethodVerifier::RejectedClassesTable;
   }
 
 #if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
   inferred_reg_category_maps_lock_ = new Mutex("verifier GC maps lock");
   {
-    MutexLock mu(*inferred_reg_category_maps_lock_);
+    MutexLock mu(self, *inferred_reg_category_maps_lock_);
     inferred_reg_category_maps_ = new MethodVerifier::InferredRegCategoryMapTable;
   }
 #endif
 }
 
 void MethodVerifier::Shutdown() {
+  Thread* self = Thread::Current();
   {
-    MutexLock mu(*dex_gc_maps_lock_);
+    MutexLock mu(self, *dex_gc_maps_lock_);
     STLDeleteValues(dex_gc_maps_);
     delete dex_gc_maps_;
     dex_gc_maps_ = NULL;
@@ -3294,7 +3296,7 @@
   dex_gc_maps_lock_ = NULL;
 
   {
-    MutexLock mu(*rejected_classes_lock_);
+    MutexLock mu(self, *rejected_classes_lock_);
     delete rejected_classes_;
     rejected_classes_ = NULL;
   }
@@ -3303,7 +3305,7 @@
 
 #if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
   {
-    MutexLock mu(*inferred_reg_category_maps_lock_);
+    MutexLock mu(self, *inferred_reg_category_maps_lock_);
     STLDeleteValues(inferred_reg_category_maps_);
     delete inferred_reg_category_maps_;
     inferred_reg_category_maps_ = NULL;
@@ -3315,14 +3317,14 @@
 
 void MethodVerifier::AddRejectedClass(Compiler::ClassReference ref) {
   {
-    MutexLock mu(*rejected_classes_lock_);
+    MutexLock mu(Thread::Current(), *rejected_classes_lock_);
     rejected_classes_->insert(ref);
   }
   CHECK(IsClassRejected(ref));
 }
 
 bool MethodVerifier::IsClassRejected(Compiler::ClassReference ref) {
-  MutexLock mu(*rejected_classes_lock_);
+  MutexLock mu(Thread::Current(), *rejected_classes_lock_);
   return (rejected_classes_->find(ref) != rejected_classes_->end());
 }
 
@@ -3374,7 +3376,7 @@
 void MethodVerifier::SetInferredRegCategoryMap(Compiler::MethodReference ref,
                                           const InferredRegCategoryMap& inferred_reg_category_map) {
   {
-    MutexLock mu(*inferred_reg_category_maps_lock_);
+    MutexLock mu(Thread::Current(), *inferred_reg_category_maps_lock_);
     InferredRegCategoryMapTable::iterator it = inferred_reg_category_maps_->find(ref);
     if (it == inferred_reg_category_maps_->end()) {
       inferred_reg_category_maps_->Put(ref, &inferred_reg_category_map);
@@ -3388,7 +3390,7 @@
 
 const greenland::InferredRegCategoryMap*
 MethodVerifier::GetInferredRegCategoryMap(Compiler::MethodReference ref) {
-  MutexLock mu(*inferred_reg_category_maps_lock_);
+  MutexLock mu(Thread::Current(), *inferred_reg_category_maps_lock_);
 
   InferredRegCategoryMapTable::const_iterator it =
       inferred_reg_category_maps_->find(ref);