diff --git a/src/class_linker.h b/src/class_linker.h
index 8ad8d2d..c69c442 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -45,46 +45,61 @@
  public:
   // Creates the class linker by boot strapping from dex files.
   static ClassLinker* CreateFromCompiler(const std::vector<const DexFile*>& boot_class_path,
-                                         InternTable* intern_table);
+                                         InternTable* intern_table)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Creates the class linker from an image.
-  static ClassLinker* CreateFromImage(InternTable* intern_table);
+  static ClassLinker* CreateFromImage(InternTable* intern_table)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   ~ClassLinker();
 
   // Finds a class by its descriptor, loading it if necessary.
   // If class_loader is null, searches boot_class_path_.
-  Class* FindClass(const char* descriptor, ClassLoader* class_loader);
+  Class* FindClass(const char* descriptor, ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Class* FindSystemClass(const char* descriptor);
+  Class* FindSystemClass(const char* descriptor)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Define a new a class based on a ClassDef from a DexFile
   Class* DefineClass(const StringPiece& descriptor, ClassLoader* class_loader,
-                     const DexFile& dex_file, const DexFile::ClassDef& dex_class_def);
+                     const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
   // by the given 'class_loader'.
-  Class* LookupClass(const char* descriptor, const ClassLoader* class_loader);
+  Class* LookupClass(const char* descriptor, const ClassLoader* class_loader)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds all the classes with the given descriptor, regardless of ClassLoader.
-  void LookupClasses(const char* descriptor, std::vector<Class*>& classes);
+  void LookupClasses(const char* descriptor, std::vector<Class*>& classes)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Class* FindPrimitiveClass(char type);
+  Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // General class unloading is not supported, this is used to prune
   // unwanted classes during image writing.
-  bool RemoveClass(const char* descriptor, const ClassLoader* class_loader);
+  bool RemoveClass(const char* descriptor, const ClassLoader* class_loader)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void DumpAllClasses(int flags) const;
+  void DumpAllClasses(int flags) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void DumpForSigQuit(std::ostream& os) const;
+  void DumpForSigQuit(std::ostream& os) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
-  size_t NumLoadedClasses() const;
+  size_t NumLoadedClasses() const LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  String* ResolveString(uint32_t string_idx, const Method* referrer) {
+  String* ResolveString(uint32_t string_idx, const Method* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx);
     if (UNLIKELY(resolved_string == NULL)) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -97,14 +112,14 @@
 
   // Resolve a String with the given index from the DexFile, storing the
   // result in the DexCache.
-  String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache);
+  String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identity the
   // target DexCache and ClassLoader to use for resolution.
-  Class* ResolveType(const DexFile& dex_file,
-                     uint16_t type_idx,
-                     const Class* referrer) {
+  Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, const Class* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ResolveType(dex_file,
                        type_idx,
                        referrer->GetDexCache(),
@@ -114,7 +129,8 @@
   // Resolve a Type with the given index from the DexFile, storing the
   // result in the DexCache. The referrer is used to identify the
   // target DexCache and ClassLoader to use for resolution.
-  Class* ResolveType(uint16_t type_idx, const Method* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Method* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
     if (UNLIKELY(resolved_type == NULL)) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -126,7 +142,8 @@
     return resolved_type;
   }
 
-  Class* ResolveType(uint16_t type_idx, const Field* referrer) {
+  Class* ResolveType(uint16_t type_idx, const Field* referrer)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Class* declaring_class = referrer->GetDeclaringClass();
     DexCache* dex_cache = declaring_class->GetDexCache();
     Class* resolved_type = dex_cache->GetResolvedType(type_idx);
@@ -145,7 +162,8 @@
   Class* ResolveType(const DexFile& dex_file,
                      uint16_t type_idx,
                      DexCache* dex_cache,
-                     ClassLoader* class_loader);
+                     ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a method with a given ID from the DexFile, storing the
   // result in DexCache. The ClassLinker and ClassLoader are used as
@@ -156,9 +174,11 @@
                         uint32_t method_idx,
                         DexCache* dex_cache,
                         ClassLoader* class_loader,
-                        bool is_direct);
+                        bool is_direct)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* ResolveMethod(uint32_t method_idx, const Method* referrer, bool is_direct) {
+  Method* ResolveMethod(uint32_t method_idx, const Method* referrer, bool is_direct)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Method* resolved_method = referrer->GetDexCacheResolvedMethods()->Get(method_idx);
     if (UNLIKELY(resolved_method == NULL || resolved_method->IsRuntimeMethod())) {
       Class* declaring_class = referrer->GetDeclaringClass();
@@ -170,7 +190,8 @@
     return resolved_method;
   }
 
-  Field* ResolveField(uint32_t field_idx, const Method* referrer, bool is_static) {
+  Field* ResolveField(uint32_t field_idx, const Method* referrer, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     Field* resolved_field =
         referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
     if (UNLIKELY(resolved_field == NULL)) {
@@ -192,7 +213,8 @@
                       uint32_t field_idx,
                       DexCache* dex_cache,
                       ClassLoader* class_loader,
-                      bool is_static);
+                      bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Resolve a field with a given ID from the DexFile, storing the
   // result in DexCache. The ClassLinker and ClassLoader are used as
@@ -201,89 +223,132 @@
   Field* ResolveFieldJLS(const DexFile& dex_file,
                          uint32_t field_idx,
                          DexCache* dex_cache,
-                         ClassLoader* class_loader);
+                         ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get shorty from method index without resolution. Used to do handlerization.
-  const char* MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length);
+  const char* MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Returns true on success, false if there's an exception pending.
   // can_run_clinit=false allows the compiler to attempt to init a class,
   // given the restriction that no <clinit> execution is possible.
-  bool EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields);
+  bool EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initializes classes that have instances in the image but that have
   // <clinit> methods so they could not be initialized by the compiler.
-  void RunRootClinits();
+  void RunRootClinits() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterDexFile(const DexFile& dex_file);
-  void RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache);
+  void RegisterDexFile(const DexFile& dex_file)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterOatFile(const OatFile& oat_file);
+  void RegisterOatFile(const OatFile& oat_file)
+      LOCKS_EXCLUDED(dex_lock_);
 
   const std::vector<const DexFile*>& GetBootClassPath() {
     return boot_class_path_;
   }
 
-  void VisitClasses(ClassVisitor* visitor, void* arg) const;
+  void VisitClasses(ClassVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
+  // Less efficient variant of VisitClasses that doesn't hold the classlinker_classes_lock_
+  // when calling the visitor.
+  void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_);
 
-  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
+  void VisitRoots(Heap::RootVisitor* visitor, void* arg) const
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_, dex_lock_);
 
-  const DexFile& FindDexFile(const DexCache* dex_cache) const;
-  DexCache* FindDexCache(const DexFile& dex_file) const;
-  bool IsDexFileRegistered(const DexFile& dex_file) const;
-  void FixupDexCaches(Method* resolution_method) const;
+  const DexFile& FindDexFile(const DexCache* dex_cache) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  DexCache* FindDexCache(const DexFile& dex_file) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool IsDexFileRegistered(const DexFile& dex_file) const
+      LOCKS_EXCLUDED(dex_lock_);
+  void FixupDexCaches(Method* resolution_method) const
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Generate an oat file from a dex file
   bool GenerateOatFile(const std::string& dex_filename,
                        int oat_fd,
                        const std::string& oat_cache_filename);
 
-  const OatFile* FindOatFileFromOatLocation(const std::string& location);
+  const OatFile* FindOatFileFromOatLocation(const std::string& location)
+      LOCKS_EXCLUDED(dex_lock_);
+
+  const OatFile* FindOatFileFromOatLocationLocked(const std::string& location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
 
   // Finds the oat file for a dex location, generating the oat file if
   // it is missing or out of date. Returns the DexFile from within the
   // created oat file.
   const DexFile* FindOrCreateOatFileForDexLocation(const std::string& dex_location,
-                                                   const std::string& oat_location);
+                                                   const std::string& oat_location)
+      LOCKS_EXCLUDED(dex_lock_);
+  const DexFile* FindOrCreateOatFileForDexLocationLocked(const std::string& dex_location,
+                                                         const std::string& oat_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
   // Find a DexFile within an OatFile given a DexFile location. Note
   // that this returns null if the location checksum of the DexFile
   // does not match the OatFile.
-  const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location);
+  const DexFile* FindDexFileInOatFileFromDexLocation(const std::string& location)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
   // Returns true if oat file contains the dex file with the given location and checksum
   static bool VerifyOatFileChecksums(const OatFile* oat_file,
                                      const std::string& dex_location,
-                                     uint32_t dex_location_checksum);
+                                     uint32_t dex_location_checksum)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // TODO: replace this with multiple methods that allocate the correct managed type.
   template <class T>
-  ObjectArray<T>* AllocObjectArray(size_t length) {
+  ObjectArray<T>* AllocObjectArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ObjectArray<T>::Alloc(GetClassRoot(kObjectArrayClass), length);
   }
 
-  ObjectArray<Class>* AllocClassArray(size_t length) {
+  ObjectArray<Class>* AllocClassArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return ObjectArray<Class>::Alloc(GetClassRoot(kClassArrayClass), length);
   }
 
-  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length);
+  ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void VerifyClass(Class* klass);
+  void VerifyClass(Class* klass) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
-                               Class::Status& oat_file_class_status);
-  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass);
-  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* klass);
+                               Class::Status& oat_file_class_status)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
-                          ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws);
-  std::string GetDescriptorForProxy(const Class* proxy_class);
-  Method* FindMethodForProxy(const Class* proxy_class, const Method* proxy_method);
+                          ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  std::string GetDescriptorForProxy(const Class* proxy_class)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* FindMethodForProxy(const Class* proxy_class, const Method* proxy_method)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Get the oat code for a method when its class isn't yet initialized
-  const void* GetOatCodeFor(const Method* method);
+  const void* GetOatCodeFor(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Relocate the OatFiles (ELF images)
-  void RelocateExecutable();
+  void RelocateExecutable() LOCKS_EXCLUDED(dex_lock_);
 
   pid_t GetClassesLockOwner(); // For SignalCatcher.
   pid_t GetDexLockOwner(); // For SignalCatcher.
@@ -291,47 +356,60 @@
  private:
   explicit ClassLinker(InternTable*);
 
-  const OatFile::OatMethod GetOatMethodFor(const Method* method);
+  const OatFile::OatMethod GetOatMethodFor(const Method* method)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initialize class linker by bootstraping from dex files
-  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path);
+  void InitFromCompiler(const std::vector<const DexFile*>& boot_class_path)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Initialize class linker from one or more images.
-  void InitFromImage();
-  OatFile* OpenOat(const ImageSpace* space);
-  static void InitFromImageCallback(Object* obj, void* arg);
+  void InitFromImage() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  OatFile* OpenOat(const ImageSpace* space)
+      LOCKS_EXCLUDED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  static void InitFromImageCallback(Object* obj, void* arg)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void FinishInit();
+  void FinishInit() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // For early bootstrapping by Init
-  Class* AllocClass(Class* java_lang_Class, size_t class_size);
+  Class* AllocClass(Class* java_lang_Class, size_t class_size)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Alloc* convenience functions to avoid needing to pass in Class*
   // values that are known to the ClassLinker such as
   // kObjectArrayClass and kJavaLangString etc.
-  Class* AllocClass(size_t class_size);
-  DexCache* AllocDexCache(const DexFile& dex_file);
-  Field* AllocField();
+  Class* AllocClass(size_t class_size) SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  DexCache* AllocDexCache(const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Field* AllocField() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* AllocMethod() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* AllocMethod();
+  InterfaceEntry* AllocInterfaceEntry(Class* interface)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  InterfaceEntry* AllocInterfaceEntry(Class* interface);
-
-  Class* CreatePrimitiveClass(const char* descriptor, Primitive::Type type) {
+  Class* CreatePrimitiveClass(const char* descriptor, Primitive::Type type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     return InitializePrimitiveClass(AllocClass(sizeof(Class)), descriptor, type);
   }
   Class* InitializePrimitiveClass(Class* primitive_class,
                                   const char* descriptor,
-                                  Primitive::Type type);
+                                  Primitive::Type type)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
-  Class* CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader);
+  Class* CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void AppendToBootClassPath(const DexFile& dex_file);
-  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache);
+  void AppendToBootClassPath(const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
-                         Class* c, SafeMap<uint32_t, Field*>& field_map);
+                         Class* c, SafeMap<uint32_t, Field*>& field_map)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   size_t SizeOfClass(const DexFile& dex_file,
                      const DexFile::ClassDef& dex_class_def);
@@ -339,15 +417,18 @@
   void LoadClass(const DexFile& dex_file,
                  const DexFile::ClassDef& dex_class_def,
                  SirtRef<Class>& klass,
-                 ClassLoader* class_loader);
+                 ClassLoader* class_loader)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
                  SirtRef<Field>& dst);
 
   void LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& dex_method,
-                  SirtRef<Class>& klass, SirtRef<Method>& dst);
+                  SirtRef<Class>& klass, SirtRef<Method>& dst)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void FixupStaticTrampolines(Class* klass);
+  void FixupStaticTrampolines(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // Finds the associated oat class for a dex_file and descriptor
   const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor);
@@ -355,68 +436,97 @@
   // Attempts to insert a class into a class table.  Returns NULL if
   // the class was inserted, otherwise returns an existing class with
   // the same descriptor and ClassLoader.
-  Class* InsertClass(const StringPiece& descriptor, Class* klass, bool image_class);
+  Class* InsertClass(const StringPiece& descriptor, Class* klass, bool image_class)
+      LOCKS_EXCLUDED(GlobalSynchronization::classlinker_classes_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool IsDexFileRegisteredLocked(const DexFile& dex_file) const EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
-  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
 
-  bool InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics);
+  bool InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   bool WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock);
-  bool ValidateSuperClassDescriptors(const Class* klass);
-  bool InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields);
+  bool ValidateSuperClassDescriptors(const Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   // Initialize static fields, returns true if fields were initialized.
-  bool InitializeStaticFields(Class* klass);
+  bool InitializeStaticFields(Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
                                                 const Class* klass1,
-                                                const Class* klass2);
+                                                const Class* klass2)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   bool IsSameMethodSignatureInDifferentClassContexts(const Method* descriptor,
                                                      const Class* klass1,
-                                                     const Class* klass2);
+                                                     const Class* klass2)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkSuperClass(SirtRef<Class>& klass);
+  bool LinkSuperClass(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file);
+  bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkVirtualMethods(SirtRef<Class>& klass);
+  bool LinkVirtualMethods(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces);
+  bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  bool LinkStaticFields(SirtRef<Class>& klass);
-  bool LinkInstanceFields(SirtRef<Class>& klass);
-  bool LinkFields(SirtRef<Class>& klass, bool is_static);
+  bool LinkStaticFields(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool LinkInstanceFields(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  bool LinkFields(SirtRef<Class>& klass, bool is_static)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
 
-  void CreateReferenceInstanceOffsets(SirtRef<Class>& klass);
-  void CreateReferenceStaticOffsets(SirtRef<Class>& klass);
+  void CreateReferenceInstanceOffsets(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  void CreateReferenceStaticOffsets(SirtRef<Class>& klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
   void CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
-                              uint32_t reference_offsets);
+                              uint32_t reference_offsets)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   // For use by ImageWriter to find DexCaches for its roots
   const std::vector<DexCache*>& GetDexCaches() {
     return dex_caches_;
   }
 
-  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file);
-  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location);
-  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location);
+  const OatFile* FindOpenedOatFileForDexFile(const DexFile& dex_file)
+      LOCKS_EXCLUDED(dex_lock_);
+  const OatFile* FindOpenedOatFileFromDexLocation(const std::string& dex_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+  const OatFile* FindOpenedOatFileFromOatLocation(const std::string& oat_location)
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
   const DexFile* VerifyAndOpenDexFileFromOatFile(const OatFile* oat_file,
                                                  const std::string& dex_location,
                                                  uint32_t dex_location_checksum)
-      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
+      EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
-  Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class);
-  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype);
+  Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
+  Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   std::vector<const DexFile*> boot_class_path_;
 
-  mutable Mutex dex_lock_;
+  mutable Mutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
   std::vector<const DexFile*> dex_files_ GUARDED_BY(dex_lock_);
   std::vector<DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
   std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
@@ -425,13 +535,14 @@
   // multimap from a string hash code of a class descriptor to
   // Class* instances. Results should be compared for a matching
   // Class::descriptor_ and Class::class_loader_.
-  mutable Mutex classes_lock_;
   typedef std::multimap<size_t, Class*> Table;
-  Table image_classes_  GUARDED_BY(classes_lock_);
-  Table classes_ GUARDED_BY(classes_lock_);
+  Table image_classes_  GUARDED_BY(GlobalSynchronization::classlinker_classes_lock_);
+  Table classes_ GUARDED_BY(GlobalSynchronization::classlinker_classes_lock_);
 
   Class* LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
-                           size_t hash, const Table& classes) EXCLUSIVE_LOCKS_REQUIRED(classes_lock_);
+                           size_t hash, const Table& classes)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
+      EXCLUSIVE_LOCKS_REQUIRED(GlobalSynchronization::classlinker_classes_lock_);
 
   // indexes into class_roots_.
   // needs to be kept in sync with class_roots_descriptors_.
@@ -447,8 +558,6 @@
     kJavaLangReflectMethod,
     kJavaLangReflectProxy,
     kJavaLangClassLoader,
-    kDalvikSystemBaseDexClassLoader,
-    kDalvikSystemPathClassLoader,
     kJavaLangThrowable,
     kJavaLangClassNotFoundException,
     kJavaLangStackTraceElement,
@@ -474,14 +583,16 @@
   };
   ObjectArray<Class>* class_roots_;
 
-  Class* GetClassRoot(ClassRoot class_root) {
+  Class* GetClassRoot(ClassRoot class_root)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
     DCHECK(class_roots_ != NULL);
     Class* klass = class_roots_->Get(class_root);
     DCHECK(klass != NULL);
     return klass;
   }
 
-  void SetClassRoot(ClassRoot class_root, Class* klass);
+  void SetClassRoot(ClassRoot class_root, Class* klass)
+      SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_);
 
   ObjectArray<Class>* GetClassRoots() {
     DCHECK(class_roots_ != NULL);