diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 8fc8f4b..5277f3a 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -1348,7 +1348,7 @@
       DCHECK(!oat_filenames_.empty());
       for (const char* oat_filename : oat_filenames_) {
         std::unique_ptr<File> oat_file(OS::CreateEmptyFile(oat_filename));
-        if (oat_file.get() == nullptr) {
+        if (oat_file == nullptr) {
           PLOG(ERROR) << "Failed to create oat file: " << oat_filename;
           return false;
         }
@@ -1378,7 +1378,7 @@
           vdex_files_.push_back(std::move(vdex_file));
         } else {
           std::unique_ptr<File> vdex_file(OS::CreateEmptyFile(vdex_filename.c_str()));
-          if (vdex_file.get() == nullptr) {
+          if (vdex_file == nullptr) {
             PLOG(ERROR) << "Failed to open vdex file: " << vdex_filename;
             return false;
           }
@@ -1392,13 +1392,15 @@
       }
     } else {
       std::unique_ptr<File> oat_file(new File(oat_fd_, oat_location_, /* check_usage */ true));
-      if (oat_file.get() == nullptr) {
+      if (oat_file == nullptr) {
         PLOG(ERROR) << "Failed to create oat file: " << oat_location_;
         return false;
       }
       oat_file->DisableAutoClose();
       if (oat_file->SetLength(0) != 0) {
         PLOG(WARNING) << "Truncating oat file " << oat_location_ << " failed.";
+        oat_file->Erase();
+        return false;
       }
       oat_files_.push_back(std::move(oat_file));
 
@@ -1427,7 +1429,7 @@
       DCHECK_NE(output_vdex_fd_, -1);
       std::string vdex_location = ReplaceFileExtension(oat_location_, "vdex");
       std::unique_ptr<File> vdex_file(new File(output_vdex_fd_, vdex_location, /* check_usage */ true));
-      if (vdex_file.get() == nullptr) {
+      if (vdex_file == nullptr) {
         PLOG(ERROR) << "Failed to create vdex file: " << vdex_location;
         return false;
       }
@@ -1437,6 +1439,7 @@
       } else {
         if (vdex_file->SetLength(0) != 0) {
           PLOG(ERROR) << "Truncating vdex file " << vdex_location << " failed.";
+          vdex_file->Erase();
           return false;
         }
       }
diff --git a/dexlayout/dexlayout.h b/dexlayout/dexlayout.h
index 9f6e8a4..bcb7ea6 100644
--- a/dexlayout/dexlayout.h
+++ b/dexlayout/dexlayout.h
@@ -59,8 +59,7 @@
   bool show_section_headers_ = false;
   bool show_section_statistics_ = false;
   bool verbose_ = false;
-  // TODO: Set verify_output_ back to false by default. Was set to true for debugging b/62840842.
-  bool verify_output_ = true;
+  bool verify_output_ = false;
   bool visualize_pattern_ = false;
   OutputFormat output_format_ = kOutputPlain;
   const char* output_dex_directory_ = nullptr;
diff --git a/dexoptanalyzer/dexoptanalyzer.cc b/dexoptanalyzer/dexoptanalyzer.cc
index fc72bbd..51a67ca 100644
--- a/dexoptanalyzer/dexoptanalyzer.cc
+++ b/dexoptanalyzer/dexoptanalyzer.cc
@@ -229,6 +229,8 @@
     if (oat_file_assistant.IsInBootClassPath()) {
       return kNoDexOptNeeded;
     }
+
+    // TODO(calin): Pass the class loader context as an argument to dexoptanalyzer. b/62269291.
     int dexoptNeeded = oat_file_assistant.GetDexOptNeeded(
         compiler_filter_, assume_profile_changed_, downgrade_);
 
diff --git a/imgdiag/imgdiag.cc b/imgdiag/imgdiag.cc
index 63fbbc8..75cfd2c 100644
--- a/imgdiag/imgdiag.cc
+++ b/imgdiag/imgdiag.cc
@@ -31,13 +31,17 @@
 #include "art_field-inl.h"
 #include "art_method-inl.h"
 #include "base/unix_file/fd_file.h"
+#include "class_linker.h"
 #include "gc/space/image_space.h"
 #include "gc/heap.h"
 #include "mirror/class-inl.h"
 #include "mirror/object-inl.h"
 #include "image.h"
-#include "scoped_thread_state_change-inl.h"
+#include "oat.h"
+#include "oat_file.h"
+#include "oat_file_manager.h"
 #include "os.h"
+#include "scoped_thread_state_change-inl.h"
 
 #include "cmdline.h"
 #include "backtrace/BacktraceMap.h"
@@ -326,6 +330,37 @@
 };
 
 // Region analysis for mirror::Objects
+class ImgObjectVisitor : public ObjectVisitor {
+ public:
+  using ComputeDirtyFunc = std::function<void(mirror::Object* object,
+                                              const uint8_t* begin_image_ptr,
+                                              const std::set<size_t>& dirty_pages)>;
+  ImgObjectVisitor(ComputeDirtyFunc dirty_func,
+                   const uint8_t* begin_image_ptr,
+                   const std::set<size_t>& dirty_pages) :
+    dirty_func_(dirty_func),
+    begin_image_ptr_(begin_image_ptr),
+    dirty_pages_(dirty_pages) { }
+
+  virtual ~ImgObjectVisitor() OVERRIDE { }
+
+  virtual void Visit(mirror::Object* object) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
+    // Sanity check that we are reading a real mirror::Object
+    CHECK(object->GetClass() != nullptr) << "Image object at address "
+                                         << object
+                                         << " has null class";
+    if (kUseBakerReadBarrier) {
+      object->AssertReadBarrierState();
+    }
+    dirty_func_(object, begin_image_ptr_, dirty_pages_);
+  }
+
+ private:
+  ComputeDirtyFunc dirty_func_;
+  const uint8_t* begin_image_ptr_;
+  const std::set<size_t>& dirty_pages_;
+};
+
 template<>
 class RegionSpecializedBase<mirror::Object> : public RegionCommon<mirror::Object> {
  public:
@@ -339,24 +374,14 @@
         os_(*os),
         dump_dirty_objects_(dump_dirty_objects) { }
 
-  void CheckEntrySanity(const uint8_t* current) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
-    CHECK_ALIGNED(current, kObjectAlignment);
-    mirror::Object* entry = reinterpret_cast<mirror::Object*>(const_cast<uint8_t*>(current));
-    // Sanity check that we are reading a real mirror::Object
-    CHECK(entry->GetClass() != nullptr) << "Image object at address "
-                                        << entry
-                                        << " has null class";
-    if (kUseBakerReadBarrier) {
-      entry->AssertReadBarrierState();
-    }
-  }
+  // Define a common public type name for use by RegionData.
+  using VisitorClass = ImgObjectVisitor;
 
-  mirror::Object* GetNextEntry(mirror::Object* entry)
+  void VisitEntries(VisitorClass* visitor,
+                    uint8_t* base,
+                    PointerSize pointer_size)
       REQUIRES_SHARED(Locks::mutator_lock_) {
-    uint8_t* next =
-        reinterpret_cast<uint8_t*>(entry) + RoundUp(EntrySize(entry), kObjectAlignment);
-    return reinterpret_cast<mirror::Object*>(next);
+    RegionCommon<mirror::Object>::image_header_.VisitObjects(visitor, base, pointer_size);
   }
 
   void VisitEntry(mirror::Object* entry)
@@ -616,40 +641,93 @@
 };
 
 // Region analysis for ArtMethods.
-// TODO: most of these need work.
+class ImgArtMethodVisitor : public ArtMethodVisitor {
+ public:
+  using ComputeDirtyFunc = std::function<void(ArtMethod*,
+                                              const uint8_t*,
+                                              const std::set<size_t>&)>;
+  ImgArtMethodVisitor(ComputeDirtyFunc dirty_func,
+                      const uint8_t* begin_image_ptr,
+                      const std::set<size_t>& dirty_pages) :
+    dirty_func_(dirty_func),
+    begin_image_ptr_(begin_image_ptr),
+    dirty_pages_(dirty_pages) { }
+  virtual ~ImgArtMethodVisitor() OVERRIDE { }
+  virtual void Visit(ArtMethod* method) OVERRIDE {
+    dirty_func_(method, begin_image_ptr_, dirty_pages_);
+  }
+
+ private:
+  ComputeDirtyFunc dirty_func_;
+  const uint8_t* begin_image_ptr_;
+  const std::set<size_t>& dirty_pages_;
+};
+
+// Struct and functor for computing offsets of members of ArtMethods.
+// template <typename RegionType>
+struct MemberInfo {
+  template <typename T>
+  void operator() (const ArtMethod* method, const T* member_address, const std::string& name) {
+    // Check that member_address is a pointer inside *method.
+    DCHECK(reinterpret_cast<uintptr_t>(method) <= reinterpret_cast<uintptr_t>(member_address));
+    DCHECK(reinterpret_cast<uintptr_t>(member_address) + sizeof(T) <=
+           reinterpret_cast<uintptr_t>(method) + sizeof(ArtMethod));
+    size_t offset =
+        reinterpret_cast<uintptr_t>(member_address) - reinterpret_cast<uintptr_t>(method);
+    offset_to_name_size_.insert({offset, NameAndSize(sizeof(T), name)});
+  }
+
+  struct NameAndSize {
+    size_t size_;
+    std::string name_;
+    NameAndSize(size_t size, const std::string& name) : size_(size), name_(name) { }
+    NameAndSize() : size_(0), name_("INVALID") { }
+  };
+
+  std::map<size_t, NameAndSize> offset_to_name_size_;
+};
+
 template<>
-class RegionSpecializedBase<ArtMethod> : RegionCommon<ArtMethod> {
+class RegionSpecializedBase<ArtMethod> : public RegionCommon<ArtMethod> {
  public:
   RegionSpecializedBase(std::ostream* os,
                         std::vector<uint8_t>* remote_contents,
                         std::vector<uint8_t>* zygote_contents,
                         const backtrace_map_t& boot_map,
-                        const ImageHeader& image_header) :
-    RegionCommon<ArtMethod>(os, remote_contents, zygote_contents, boot_map, image_header),
-    os_(*os) { }
-
-  void CheckEntrySanity(const uint8_t* current ATTRIBUTE_UNUSED) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
+                        const ImageHeader& image_header,
+                        bool dump_dirty_objects ATTRIBUTE_UNUSED)
+      : RegionCommon<ArtMethod>(os, remote_contents, zygote_contents, boot_map, image_header),
+        os_(*os) {
+    // Prepare the table for offset to member lookups.
+    ArtMethod* art_method = reinterpret_cast<ArtMethod*>(&(*remote_contents)[0]);
+    art_method->VisitMembers(member_info_);
+    // Prepare the table for address to symbolic entry point names.
+    BuildEntryPointNames();
+    class_linker_ = Runtime::Current()->GetClassLinker();
   }
 
-  ArtMethod* GetNextEntry(ArtMethod* entry)
+  // Define a common public type name for use by RegionData.
+  using VisitorClass = ImgArtMethodVisitor;
+
+  void VisitEntries(VisitorClass* visitor,
+                    uint8_t* base,
+                    PointerSize pointer_size)
       REQUIRES_SHARED(Locks::mutator_lock_) {
-    uint8_t* next = reinterpret_cast<uint8_t*>(entry) + RoundUp(EntrySize(entry), kObjectAlignment);
-    return reinterpret_cast<ArtMethod*>(next);
+    RegionCommon<ArtMethod>::image_header_.VisitPackedArtMethods(visitor, base, pointer_size);
   }
 
   void VisitEntry(ArtMethod* method ATTRIBUTE_UNUSED)
       REQUIRES_SHARED(Locks::mutator_lock_) {
   }
 
+  void AddCleanEntry(ArtMethod* method ATTRIBUTE_UNUSED) {
+  }
+
   void AddFalseDirtyEntry(ArtMethod* method)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     RegionCommon<ArtMethod>::AddFalseDirtyEntry(method);
   }
 
-  void AddCleanEntry(ArtMethod* method ATTRIBUTE_UNUSED) {
-  }
-
   void AddDirtyEntry(ArtMethod* method, ArtMethod* method_remote)
       REQUIRES_SHARED(Locks::mutator_lock_) {
     size_t entry_size = EntrySize(method);
@@ -667,14 +745,50 @@
     dirty_entries_.push_back(method);
   }
 
-  void DiffEntryContents(ArtMethod* method ATTRIBUTE_UNUSED,
-                         uint8_t* remote_bytes ATTRIBUTE_UNUSED,
-                         const uint8_t* base_ptr ATTRIBUTE_UNUSED)
+  void DiffEntryContents(ArtMethod* method,
+                         uint8_t* remote_bytes,
+                         const uint8_t* base_ptr,
+                         bool log_dirty_objects ATTRIBUTE_UNUSED)
       REQUIRES_SHARED(Locks::mutator_lock_) {
+    const char* tabs = "    ";
+    os_ << tabs << "ArtMethod " << ArtMethod::PrettyMethod(method) << "\n";
+
+    std::unordered_set<size_t> dirty_members;
+    // Examine the members comprising the ArtMethod, computing which members are dirty.
+    for (const std::pair<size_t, MemberInfo::NameAndSize>& p : member_info_.offset_to_name_size_) {
+      const size_t offset = p.first;
+      if (memcmp(base_ptr + offset, remote_bytes + offset, p.second.size_) != 0) {
+        dirty_members.insert(p.first);
+      }
+    }
+    // Dump different fields.
+    if (!dirty_members.empty()) {
+      os_ << tabs << "Dirty members " << dirty_members.size() << "\n";
+      for (size_t offset : dirty_members) {
+        const MemberInfo::NameAndSize& member_info = member_info_.offset_to_name_size_[offset];
+        os_ << tabs << member_info.name_
+            << " original=" << StringFromBytes(base_ptr + offset, member_info.size_)
+            << " remote=" << StringFromBytes(remote_bytes + offset, member_info.size_)
+            << "\n";
+      }
+    }
+    os_ << "\n";
+  }
+
+  void DumpDirtyObjects() REQUIRES_SHARED(Locks::mutator_lock_) {
   }
 
   void DumpDirtyEntries() REQUIRES_SHARED(Locks::mutator_lock_) {
     DumpSamplesAndOffsetCount();
+    os_ << "      offset to field map:\n";
+    for (const std::pair<size_t, MemberInfo::NameAndSize>& p : member_info_.offset_to_name_size_) {
+      const size_t offset = p.first;
+      const size_t size = p.second.size_;
+      os_ << StringPrintf("        %zu-%zu: ", offset, offset + size - 1)
+          << p.second.name_
+          << std::endl;
+    }
+
     os_ << "      field contents:\n";
     for (ArtMethod* method : dirty_entries_) {
       // remote method
@@ -694,6 +808,7 @@
   }
 
   void DumpFalseDirtyEntries() REQUIRES_SHARED(Locks::mutator_lock_) {
+    os_ << "\n" << "  False-dirty ArtMethods\n";
     os_ << "      field contents:\n";
     for (ArtMethod* method : false_dirty_entries_) {
       // local class
@@ -707,6 +822,84 @@
 
  private:
   std::ostream& os_;
+  MemberInfo member_info_;
+  std::map<const void*, std::string> entry_point_names_;
+  ClassLinker* class_linker_;
+
+  // Compute a map of addresses to names in the boot OAT file(s).
+  void BuildEntryPointNames() {
+    OatFileManager& oat_file_manager = Runtime::Current()->GetOatFileManager();
+    std::vector<const OatFile*> boot_oat_files = oat_file_manager.GetBootOatFiles();
+    for (const OatFile* oat_file : boot_oat_files) {
+      const OatHeader& oat_header = oat_file->GetOatHeader();
+      const void* i2ib = oat_header.GetInterpreterToInterpreterBridge();
+      if (i2ib != nullptr) {
+        entry_point_names_[i2ib] = "InterpreterToInterpreterBridge (from boot oat file)";
+      }
+      const void* i2ccb = oat_header.GetInterpreterToCompiledCodeBridge();
+      if (i2ccb != nullptr) {
+        entry_point_names_[i2ccb] = "InterpreterToCompiledCodeBridge (from boot oat file)";
+      }
+      const void* jdl = oat_header.GetJniDlsymLookup();
+      if (jdl != nullptr) {
+        entry_point_names_[jdl] = "JniDlsymLookup (from boot oat file)";
+      }
+      const void* qgjt = oat_header.GetQuickGenericJniTrampoline();
+      if (qgjt != nullptr) {
+        entry_point_names_[qgjt] = "QuickGenericJniTrampoline (from boot oat file)";
+      }
+      const void* qrt = oat_header.GetQuickResolutionTrampoline();
+      if (qrt != nullptr) {
+        entry_point_names_[qrt] = "QuickResolutionTrampoline (from boot oat file)";
+      }
+      const void* qict = oat_header.GetQuickImtConflictTrampoline();
+      if (qict != nullptr) {
+        entry_point_names_[qict] = "QuickImtConflictTrampoline (from boot oat file)";
+      }
+      const void* q2ib = oat_header.GetQuickToInterpreterBridge();
+      if (q2ib != nullptr) {
+        entry_point_names_[q2ib] = "QuickToInterpreterBridge (from boot oat file)";
+      }
+    }
+  }
+
+  std::string StringFromBytes(const uint8_t* bytes, size_t size) {
+    switch (size) {
+      case 1:
+        return StringPrintf("%" PRIx8, *bytes);
+      case 2:
+        return StringPrintf("%" PRIx16, *reinterpret_cast<const uint16_t*>(bytes));
+      case 4:
+      case 8: {
+        // Compute an address if the bytes might contain one.
+        uint64_t intval;
+        if (size == 4) {
+          intval = *reinterpret_cast<const uint32_t*>(bytes);
+        } else {
+          intval = *reinterpret_cast<const uint64_t*>(bytes);
+        }
+        const void* addr = reinterpret_cast<const void*>(intval);
+        // Match the address against those that have Is* methods in the ClassLinker.
+        if (class_linker_->IsQuickToInterpreterBridge(addr)) {
+          return "QuickToInterpreterBridge";
+        } else if (class_linker_->IsQuickGenericJniStub(addr)) {
+          return "QuickGenericJniStub";
+        } else if (class_linker_->IsQuickResolutionStub(addr)) {
+          return "QuickResolutionStub";
+        } else if (class_linker_->IsJniDlsymLookupStub(addr)) {
+          return "JniDlsymLookupStub";
+        }
+        // Match the address against those that we saved from the boot OAT files.
+        if (entry_point_names_.find(addr) != entry_point_names_.end()) {
+          return entry_point_names_[addr];
+        }
+        return StringPrintf("%" PRIx64, intval);
+      }
+      default:
+        LOG(WARNING) << "Don't know how to convert " << size << " bytes to integer";
+        return "<UNKNOWN>";
+    }
+  }
 
   void DumpOneArtMethod(ArtMethod* art_method,
                         mirror::Class* declaring_class,
@@ -721,7 +914,10 @@
                art_method->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size))
         << ", ";
     os_ << "  isNative? " << (art_method->IsNative() ? "yes" : "no") << ", ";
-    os_ << "  class_status (local): " << declaring_class->GetStatus();
+    // Null for runtime metionds.
+    if (declaring_class != nullptr) {
+      os_ << "  class_status (local): " << declaring_class->GetStatus();
+    }
     if (remote_declaring_class != nullptr) {
       os_ << ",  class_status (remote): " << remote_declaring_class->GetStatus();
     }
@@ -755,16 +951,20 @@
   // collecting and reporting data regarding dirty, difference, etc.
   void ProcessRegion(const MappingData& mapping_data,
                      RemoteProcesses remotes,
-                     const uint8_t* begin_image_ptr,
-                     const uint8_t* end_image_ptr)
+                     const uint8_t* begin_image_ptr)
       REQUIRES_SHARED(Locks::mutator_lock_) {
-    const uint8_t* current = begin_image_ptr + RoundUp(sizeof(ImageHeader), kObjectAlignment);
-    T* entry = reinterpret_cast<T*>(const_cast<uint8_t*>(current));
-    while (reinterpret_cast<uintptr_t>(entry) < reinterpret_cast<uintptr_t>(end_image_ptr)) {
-      ComputeEntryDirty(entry, begin_image_ptr, mapping_data.dirty_page_set);
-
-      entry = RegionSpecializedBase<T>::GetNextEntry(entry);
-    }
+    typename RegionSpecializedBase<T>::VisitorClass visitor(
+        [this](T* entry,
+               const uint8_t* begin_image_ptr,
+               const std::set<size_t>& dirty_page_set) REQUIRES_SHARED(Locks::mutator_lock_) {
+          this->ComputeEntryDirty(entry, begin_image_ptr, dirty_page_set);
+        },
+        begin_image_ptr,
+        mapping_data.dirty_page_set);
+    PointerSize pointer_size = InstructionSetPointerSize(Runtime::Current()->GetInstructionSet());
+    RegionSpecializedBase<T>::VisitEntries(&visitor,
+                                           const_cast<uint8_t*>(begin_image_ptr),
+                                           pointer_size);
 
     // Looking at only dirty pages, figure out how many of those bytes belong to dirty entries.
     // TODO: fix this now that there are multiple regions in a mapping.
@@ -1208,8 +1408,6 @@
        << "\n\n";
 
     const uint8_t* image_begin_unaligned = image_header_.GetImageBegin();
-    const uint8_t* image_mirror_end_unaligned = image_begin_unaligned +
-        image_header_.GetImageSection(ImageHeader::kSectionObjects).Size();
     const uint8_t* image_end_unaligned = image_begin_unaligned + image_header_.GetImageSize();
 
     // Adjust range to nearest page
@@ -1235,14 +1433,6 @@
     if (!ComputeDirtyBytes(image_begin, &mapping_data)) {
       return false;
     }
-
-    RegionData<mirror::Object> object_region_data(os_,
-                                                  &remote_contents_,
-                                                  &zygote_contents_,
-                                                  boot_map_,
-                                                  image_header_,
-                                                  dump_dirty_objects_);
-
     RemoteProcesses remotes;
     if (zygote_pid_only_) {
       remotes = RemoteProcesses::kZygoteOnly;
@@ -1252,11 +1442,27 @@
       remotes = RemoteProcesses::kImageOnly;
     }
 
+    // Check all the mirror::Object entries in the image.
+    RegionData<mirror::Object> object_region_data(os_,
+                                                  &remote_contents_,
+                                                  &zygote_contents_,
+                                                  boot_map_,
+                                                  image_header_,
+                                                  dump_dirty_objects_);
     object_region_data.ProcessRegion(mapping_data,
                                      remotes,
-                                     image_begin_unaligned,
-                                     image_mirror_end_unaligned);
+                                     image_begin_unaligned);
 
+    // Check all the ArtMethod entries in the image.
+    RegionData<ArtMethod> artmethod_region_data(os_,
+                                                &remote_contents_,
+                                                &zygote_contents_,
+                                                boot_map_,
+                                                image_header_,
+                                                dump_dirty_objects_);
+    artmethod_region_data.ProcessRegion(mapping_data,
+                                        remotes,
+                                        image_begin_unaligned);
     return true;
   }
 
diff --git a/profman/profile_assistant.cc b/profman/profile_assistant.cc
index c238f0d..ff02b5d 100644
--- a/profman/profile_assistant.cc
+++ b/profman/profile_assistant.cc
@@ -23,8 +23,11 @@
 
 // Minimum number of new methods/classes that profiles
 // must contain to enable recompilation.
-static constexpr const uint32_t kMinNewMethodsForCompilation = 10;
-static constexpr const uint32_t kMinNewClassesForCompilation = 10;
+static constexpr const uint32_t kMinNewMethodsForCompilation = 100;
+static constexpr const uint32_t kMinNewMethodsPercentChangeForCompilation = 2;
+static constexpr const uint32_t kMinNewClassesForCompilation = 50;
+static constexpr const uint32_t kMinNewClassesPercentChangeForCompilation = 2;
+
 
 ProfileAssistant::ProcessingResult ProfileAssistant::ProcessProfilesInternal(
         const std::vector<ScopedFlock>& profile_files,
@@ -55,9 +58,16 @@
     }
   }
 
+  uint32_t min_change_in_methods_for_compilation = std::max(
+      (kMinNewMethodsPercentChangeForCompilation * number_of_methods) / 100,
+      kMinNewMethodsForCompilation);
+  uint32_t min_change_in_classes_for_compilation = std::max(
+      (kMinNewClassesPercentChangeForCompilation * number_of_classes) / 100,
+      kMinNewClassesForCompilation);
   // Check if there is enough new information added by the current profiles.
-  if (((info.GetNumberOfMethods() - number_of_methods) < kMinNewMethodsForCompilation) &&
-      ((info.GetNumberOfResolvedClasses() - number_of_classes) < kMinNewClassesForCompilation)) {
+  if (((info.GetNumberOfMethods() - number_of_methods) < min_change_in_methods_for_compilation) &&
+      ((info.GetNumberOfResolvedClasses() - number_of_classes)
+          < min_change_in_classes_for_compilation)) {
     return kSkipCompilation;
   }
 
diff --git a/profman/profile_assistant_test.cc b/profman/profile_assistant_test.cc
index c78d34e..955ec96 100644
--- a/profman/profile_assistant_test.cc
+++ b/profman/profile_assistant_test.cc
@@ -335,6 +335,46 @@
     ASSERT_EQ(expected_clases.size(), found);
   }
 
+  int CheckCompilationMethodPercentChange(uint16_t methods_in_cur_profile,
+                                          uint16_t methods_in_ref_profile) {
+    ScratchFile profile;
+    ScratchFile reference_profile;
+    std::vector<int> profile_fds({ GetFd(profile)});
+    int reference_profile_fd = GetFd(reference_profile);
+    std::vector<uint32_t> hot_methods_cur;
+    std::vector<uint32_t> hot_methods_ref;
+    std::vector<uint32_t> empty_vector;
+    for (size_t i = 0; i < methods_in_cur_profile; ++i) {
+      hot_methods_cur.push_back(i);
+    }
+    for (size_t i = 0; i < methods_in_ref_profile; ++i) {
+      hot_methods_ref.push_back(i);
+    }
+    ProfileCompilationInfo info1;
+    uint16_t methods_in_profile = std::max(methods_in_cur_profile, methods_in_ref_profile);
+    SetupBasicProfile("p1", 1, methods_in_profile, hot_methods_cur, empty_vector, empty_vector,
+        profile,  &info1);
+    ProfileCompilationInfo info2;
+    SetupBasicProfile("p1", 1, methods_in_profile, hot_methods_ref, empty_vector, empty_vector,
+        reference_profile,  &info2);
+    return ProcessProfiles(profile_fds, reference_profile_fd);
+  }
+
+  int CheckCompilationClassPercentChange(uint16_t classes_in_cur_profile,
+                                         uint16_t classes_in_ref_profile) {
+    ScratchFile profile;
+    ScratchFile reference_profile;
+
+    std::vector<int> profile_fds({ GetFd(profile)});
+    int reference_profile_fd = GetFd(reference_profile);
+
+    ProfileCompilationInfo info1;
+    SetupProfile("p1", 1, 0, classes_in_cur_profile, profile,  &info1);
+    ProfileCompilationInfo info2;
+    SetupProfile("p1", 1, 0, classes_in_ref_profile, reference_profile, &info2);
+    return ProcessProfiles(profile_fds, reference_profile_fd);
+  }
+
   std::unique_ptr<ArenaAllocator> arena_;
 
   // Cache of inline caches generated during tests.
@@ -460,7 +500,7 @@
       GetFd(profile2)});
   int reference_profile_fd = GetFd(reference_profile);
 
-  const uint16_t kNumberOfMethodsToSkipCompilation = 1;
+  const uint16_t kNumberOfMethodsToSkipCompilation = 24;  // Threshold is 100.
   ProfileCompilationInfo info1;
   SetupProfile("p1", 1, kNumberOfMethodsToSkipCompilation, 0, profile1, &info1);
   ProfileCompilationInfo info2;
@@ -489,6 +529,42 @@
   CheckProfileInfo(profile2, info2);
 }
 
+TEST_F(ProfileAssistantTest, DoNotAdviseCompilationMethodPercentage) {
+  const uint16_t kNumberOfMethodsInRefProfile = 6000;
+  const uint16_t kNumberOfMethodsInCurProfile = 6100;  // Threshold is 2%.
+  // We should not advise compilation.
+  ASSERT_EQ(ProfileAssistant::kSkipCompilation,
+            CheckCompilationMethodPercentChange(kNumberOfMethodsInCurProfile,
+                                                kNumberOfMethodsInRefProfile));
+}
+
+TEST_F(ProfileAssistantTest, ShouldAdviseCompilationMethodPercentage) {
+  const uint16_t kNumberOfMethodsInRefProfile = 6000;
+  const uint16_t kNumberOfMethodsInCurProfile = 6200;  // Threshold is 2%.
+  // We should advise compilation.
+  ASSERT_EQ(ProfileAssistant::kCompile,
+            CheckCompilationMethodPercentChange(kNumberOfMethodsInCurProfile,
+                                                kNumberOfMethodsInRefProfile));
+}
+
+TEST_F(ProfileAssistantTest, DoNotdviseCompilationClassPercentage) {
+  const uint16_t kNumberOfClassesInRefProfile = 6000;
+  const uint16_t kNumberOfClassesInCurProfile = 6110;  // Threshold is 2%.
+  // We should not advise compilation.
+  ASSERT_EQ(ProfileAssistant::kSkipCompilation,
+            CheckCompilationClassPercentChange(kNumberOfClassesInCurProfile,
+                                               kNumberOfClassesInRefProfile));
+}
+
+TEST_F(ProfileAssistantTest, ShouldAdviseCompilationClassPercentage) {
+  const uint16_t kNumberOfClassesInRefProfile = 6000;
+  const uint16_t kNumberOfClassesInCurProfile = 6120;  // Threshold is 2%.
+  // We should advise compilation.
+  ASSERT_EQ(ProfileAssistant::kCompile,
+            CheckCompilationClassPercentChange(kNumberOfClassesInCurProfile,
+                                               kNumberOfClassesInRefProfile));
+}
+
 TEST_F(ProfileAssistantTest, FailProcessingBecauseOfProfiles) {
   ScratchFile profile1;
   ScratchFile profile2;
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 511ac83..0de4efd 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -684,6 +684,27 @@
   template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier, typename Visitor>
   ALWAYS_INLINE void UpdateEntrypoints(const Visitor& visitor, PointerSize pointer_size);
 
+  // Visit the individual members of an ArtMethod.  Used by imgdiag.
+  // As imgdiag does not support mixing instruction sets or pointer sizes (e.g., using imgdiag32
+  // to inspect 64-bit images, etc.), we can go beneath the accessors directly to the class members.
+  template <typename VisitorFunc>
+  void VisitMembers(VisitorFunc& visitor) {
+    DCHECK(IsImagePointerSize(kRuntimePointerSize));
+    visitor(this, &declaring_class_, "declaring_class_");
+    visitor(this, &access_flags_, "access_flags_");
+    visitor(this, &dex_code_item_offset_, "dex_code_item_offset_");
+    visitor(this, &dex_method_index_, "dex_method_index_");
+    visitor(this, &method_index_, "method_index_");
+    visitor(this, &hotness_count_, "hotness_count_");
+    visitor(this,
+            &ptr_sized_fields_.dex_cache_resolved_methods_,
+            "ptr_sized_fields_.dex_cache_resolved_methods_");
+    visitor(this, &ptr_sized_fields_.data_, "ptr_sized_fields_.data_");
+    visitor(this,
+            &ptr_sized_fields_.entry_point_from_quick_compiled_code_,
+            "ptr_sized_fields_.entry_point_from_quick_compiled_code_");
+  }
+
  protected:
   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
   // The class we are a part of.
diff --git a/runtime/base/unix_file/fd_file.cc b/runtime/base/unix_file/fd_file.cc
index 20e0cfa..fd567af 100644
--- a/runtime/base/unix_file/fd_file.cc
+++ b/runtime/base/unix_file/fd_file.cc
@@ -69,7 +69,7 @@
     if (guard_state_ < GuardState::kClosed) {
       LOG(ERROR) << "File " << file_path_ << " wasn't explicitly closed before destruction.";
     }
-    CHECK_GE(guard_state_, GuardState::kClosed);
+    DCHECK_GE(guard_state_, GuardState::kClosed);
   }
   if (auto_close_ && fd_ != -1) {
     if (Close() != 0) {
@@ -134,7 +134,7 @@
 
 bool FdFile::Open(const std::string& path, int flags, mode_t mode) {
   static_assert(O_RDONLY == 0, "Readonly flag has unexpected value.");
-  CHECK_EQ(fd_, -1) << path;
+  DCHECK_EQ(fd_, -1) << path;
   read_only_mode_ = ((flags & O_ACCMODE) == O_RDONLY);
   fd_ = TEMP_FAILURE_RETRY(open(path.c_str(), flags, mode));
   if (fd_ == -1) {
@@ -157,7 +157,7 @@
 
   // Test here, so the file is closed and not leaked.
   if (kCheckSafeUsage) {
-    CHECK_GE(guard_state_, GuardState::kFlushed) << "File " << file_path_
+    DCHECK_GE(guard_state_, GuardState::kFlushed) << "File " << file_path_
         << " has not been flushed before closing.";
     moveUp(GuardState::kClosed, nullptr);
   }
@@ -173,13 +173,20 @@
 
 int FdFile::Flush() {
   DCHECK(!read_only_mode_);
+
 #ifdef __linux__
   int rc = TEMP_FAILURE_RETRY(fdatasync(fd_));
 #else
   int rc = TEMP_FAILURE_RETRY(fsync(fd_));
 #endif
+
   moveUp(GuardState::kFlushed, "Flushing closed file.");
-  return (rc == -1) ? -errno : rc;
+  if (rc == 0) {
+    return 0;
+  }
+
+  // Don't report failure if we just tried to flush a pipe or socket.
+  return errno == EINVAL ? 0 : -errno;
 }
 
 int64_t FdFile::Read(char* buf, int64_t byte_count, int64_t offset) const {
diff --git a/runtime/base/unix_file/fd_file.h b/runtime/base/unix_file/fd_file.h
index 7db077d..8fc6e02 100644
--- a/runtime/base/unix_file/fd_file.h
+++ b/runtime/base/unix_file/fd_file.h
@@ -94,6 +94,7 @@
   int SetLength(int64_t new_length) OVERRIDE WARN_UNUSED;
   int64_t GetLength() const OVERRIDE;
   int64_t Write(const char* buf, int64_t byte_count, int64_t offset) OVERRIDE WARN_UNUSED;
+
   int Flush() OVERRIDE WARN_UNUSED;
 
   // Short for SetLength(0); Flush(); Close();
diff --git a/runtime/base/unix_file/fd_file_test.cc b/runtime/base/unix_file/fd_file_test.cc
index 8b1a115..042fbc9 100644
--- a/runtime/base/unix_file/fd_file_test.cc
+++ b/runtime/base/unix_file/fd_file_test.cc
@@ -274,4 +274,15 @@
   EXPECT_EQ(reset_compare(tmp, tmp6), 0);
 }
 
+TEST_F(FdFileTest, PipeFlush) {
+  int pipefd[2];
+  ASSERT_EQ(0, pipe2(pipefd, O_CLOEXEC));
+
+  FdFile file(pipefd[1], true);
+  ASSERT_TRUE(file.WriteFully("foo", 3));
+  ASSERT_EQ(0, file.Flush());
+  ASSERT_EQ(0, file.FlushCloseOrErase());
+  close(pipefd[0]);
+}
+
 }  // namespace unix_file
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index dfb278d..855359e 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -8590,6 +8590,10 @@
       (quick_generic_jni_trampoline_ == entry_point);
 }
 
+bool ClassLinker::IsJniDlsymLookupStub(const void* entry_point) const {
+  return entry_point == GetJniDlsymLookupStub();
+}
+
 const void* ClassLinker::GetRuntimeQuickGenericJniStub() const {
   return GetQuickGenericJniStub();
 }
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 2c2f30b..d18c15d 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -506,6 +506,9 @@
   // Is the given entry point quick code to run the generic JNI stub?
   bool IsQuickGenericJniStub(const void* entry_point) const;
 
+  // Is the given entry point the JNI dlsym lookup stub?
+  bool IsJniDlsymLookupStub(const void* entry_point) const;
+
   const void* GetQuickToInterpreterBridgeTrampoline() const {
     return quick_to_interpreter_bridge_trampoline_;
   }
diff --git a/runtime/class_loader_context.cc b/runtime/class_loader_context.cc
index e97c6a0..ef274b1 100644
--- a/runtime/class_loader_context.cc
+++ b/runtime/class_loader_context.cc
@@ -187,7 +187,10 @@
 // Opens requested class path files and appends them to opened_dex_files. If the dex files have
 // been stripped, this opens them from their oat files (which get added to opened_oat_files).
 bool ClassLoaderContext::OpenDexFiles(InstructionSet isa, const std::string& classpath_dir) {
-  CHECK(!dex_files_open_attempted_) << "OpenDexFiles should not be called twice";
+  if (dex_files_open_attempted_) {
+    // Do not attempt to re-open the files if we already tried.
+    return dex_files_open_result_;
+  }
 
   dex_files_open_attempted_ = true;
   // Assume we can open all dex files. If not, we will set this to false as we go.
@@ -203,6 +206,7 @@
   // TODO(calin): Refine the dex opening interface to be able to tell if an archive contains
   // no dex files. So that we can distinguish the real failures...
   for (ClassLoaderInfo& info : class_loader_chain_) {
+    size_t opened_dex_files_index = info.opened_dex_files.size();
     for (const std::string& cp_elem : info.classpath) {
       // If path is relative, append it to the provided base directory.
       std::string raw_location = cp_elem;
@@ -249,6 +253,23 @@
         }
       }
     }
+
+    // We finished opening the dex files from the classpath.
+    // Now update the classpath and the checksum with the locations of the dex files.
+    //
+    // We do this because initially the classpath contains the paths of the dex files; and
+    // some of them might be multi-dexes. So in order to have a consistent view we replace all the
+    // file paths with the actual dex locations being loaded.
+    // This will allow the context to VerifyClassLoaderContextMatch which expects or multidex
+    // location in the class paths.
+    // Note that this will also remove the paths that could not be opened.
+    info.classpath.clear();
+    info.checksums.clear();
+    for (size_t k = opened_dex_files_index; k < info.opened_dex_files.size(); k++) {
+      std::unique_ptr<const DexFile>& dex = info.opened_dex_files[k];
+      info.classpath.push_back(dex->GetLocation());
+      info.checksums.push_back(dex->GetLocationChecksum());
+    }
   }
 
   return dex_files_open_result_;
@@ -632,14 +653,25 @@
   }
 }
 
+static bool IsAbsoluteLocation(const std::string& location) {
+  return !location.empty() && location[0] == '/';
+}
+
 bool ClassLoaderContext::VerifyClassLoaderContextMatch(const std::string& context_spec) const {
+  DCHECK(dex_files_open_attempted_);
+  DCHECK(dex_files_open_result_);
+
   ClassLoaderContext expected_context;
   if (!expected_context.Parse(context_spec, /*parse_checksums*/ true)) {
     LOG(WARNING) << "Invalid class loader context: " << context_spec;
     return false;
   }
 
-  if (expected_context.special_shared_library_) {
+  // Special shared library contexts always match. They essentially instruct the runtime
+  // to ignore the class path check because the oat file is known to be loaded in different
+  // contexts. OatFileManager will further verify if the oat file can be loaded based on the
+  // collision check.
+  if (special_shared_library_ || expected_context.special_shared_library_) {
     return true;
   }
 
@@ -673,18 +705,52 @@
     DCHECK_EQ(expected_info.classpath.size(), expected_info.checksums.size());
 
     for (size_t k = 0; k < info.classpath.size(); k++) {
-      if (info.classpath[k] != expected_info.classpath[k]) {
+      // Compute the dex location that must be compared.
+      // We shouldn't do a naive comparison `info.classpath[k] == expected_info.classpath[k]`
+      // because even if they refer to the same file, one could be encoded as a relative location
+      // and the other as an absolute one.
+      bool is_dex_name_absolute = IsAbsoluteLocation(info.classpath[k]);
+      bool is_expected_dex_name_absolute = IsAbsoluteLocation(expected_info.classpath[k]);
+      std::string dex_name;
+      std::string expected_dex_name;
+
+      if (is_dex_name_absolute == is_expected_dex_name_absolute) {
+        // If both locations are absolute or relative then compare them as they are.
+        // This is usually the case for: shared libraries and secondary dex files.
+        dex_name = info.classpath[k];
+        expected_dex_name = expected_info.classpath[k];
+      } else if (is_dex_name_absolute) {
+        // The runtime name is absolute but the compiled name (the expected one) is relative.
+        // This is the case for split apks which depend on base or on other splits.
+        dex_name = info.classpath[k];
+        expected_dex_name = OatFile::ResolveRelativeEncodedDexLocation(
+            info.classpath[k].c_str(), expected_info.classpath[k]);
+      } else {
+        // The runtime name is relative but the compiled name is absolute.
+        // There is no expected use case that would end up here as dex files are always loaded
+        // with their absolute location. However, be tolerant and do the best effort (in case
+        // there are unexpected new use case...).
+        DCHECK(is_expected_dex_name_absolute);
+        dex_name = OatFile::ResolveRelativeEncodedDexLocation(
+            expected_info.classpath[k].c_str(), info.classpath[k]);
+        expected_dex_name = expected_info.classpath[k];
+      }
+
+      // Compare the locations.
+      if (dex_name != expected_dex_name) {
         LOG(WARNING) << "ClassLoaderContext classpath element mismatch for position " << i
             << ". expected=" << expected_info.classpath[k]
             << ", found=" << info.classpath[k]
             << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")";
         return false;
       }
+
+      // Compare the checksums.
       if (info.checksums[k] != expected_info.checksums[k]) {
         LOG(WARNING) << "ClassLoaderContext classpath element checksum mismatch for position " << i
-            << ". expected=" << expected_info.checksums[k]
-            << ", found=" << info.checksums[k]
-            << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")";
+                     << ". expected=" << expected_info.checksums[k]
+                     << ", found=" << info.checksums[k]
+                     << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")";
         return false;
       }
     }
diff --git a/runtime/class_loader_context.h b/runtime/class_loader_context.h
index 9afa880..692a6cd 100644
--- a/runtime/class_loader_context.h
+++ b/runtime/class_loader_context.h
@@ -41,7 +41,12 @@
   // to ClassLoaderInfo::opened_oat_files. The 'classpath_dir' argument specifies the directory to
   // use for the relative class paths.
   // Returns true if all dex files where successfully opened.
-  // It may be called only once per ClassLoaderContext. The second call will abort.
+  // It may be called only once per ClassLoaderContext. Subsequent calls will return the same
+  // result without doing anything.
+  //
+  // This will replace the class path locations with the locations of the opened dex files.
+  // (Note that one dex file can contain multidexes. Each multidex will be added to the classpath
+  // separately.)
   //
   // Note that a "false" return could mean that either an apk/jar contained no dex files or
   // that we hit a I/O or checksum mismatch error.
@@ -98,6 +103,7 @@
   //    - the number and type of the class loaders from the chain matches
   //    - the class loader from the same position have the same classpath
   //      (the order and checksum of the dex files matches)
+  // This should be called after OpenDexFiles().
   bool VerifyClassLoaderContextMatch(const std::string& context_spec) const;
 
   // Creates the class loader context from the given string.
diff --git a/runtime/class_loader_context_test.cc b/runtime/class_loader_context_test.cc
index 60b5fa4..ca6900f 100644
--- a/runtime/class_loader_context_test.cc
+++ b/runtime/class_loader_context_test.cc
@@ -74,39 +74,29 @@
   void VerifyOpenDexFiles(
       ClassLoaderContext* context,
       size_t index,
-      std::vector<std::vector<std::unique_ptr<const DexFile>>*>& all_dex_files) {
+      std::vector<std::unique_ptr<const DexFile>>* all_dex_files) {
     ASSERT_TRUE(context != nullptr);
     ASSERT_TRUE(context->dex_files_open_attempted_);
     ASSERT_TRUE(context->dex_files_open_result_);
     ClassLoaderContext::ClassLoaderInfo& info = context->class_loader_chain_[index];
-    ASSERT_EQ(all_dex_files.size(), info.classpath.size());
+    ASSERT_EQ(all_dex_files->size(), info.classpath.size());
+    ASSERT_EQ(all_dex_files->size(), info.opened_dex_files.size());
     size_t cur_open_dex_index = 0;
-    for (size_t k = 0; k < all_dex_files.size(); k++) {
-      std::vector<std::unique_ptr<const DexFile>>& dex_files_for_cp_elem = *(all_dex_files[k]);
-      for (size_t i = 0; i < dex_files_for_cp_elem.size(); i++) {
-        ASSERT_LT(cur_open_dex_index, info.opened_dex_files.size());
-
-        std::unique_ptr<const DexFile>& opened_dex_file =
+    for (size_t k = 0; k < all_dex_files->size(); k++) {
+      std::unique_ptr<const DexFile>& opened_dex_file =
             info.opened_dex_files[cur_open_dex_index++];
-        std::unique_ptr<const DexFile>& expected_dex_file = dex_files_for_cp_elem[i];
+      std::unique_ptr<const DexFile>& expected_dex_file = (*all_dex_files)[k];
 
-        std::string expected_location = expected_dex_file->GetBaseLocation();
-        UniqueCPtr<const char[]> expected_real_location(
-            realpath(expected_location.c_str(), nullptr));
-        ASSERT_TRUE(expected_real_location != nullptr) << expected_location;
-        expected_location.assign(expected_real_location.get());
-        expected_location += DexFile::GetMultiDexSuffix(expected_dex_file->GetLocation());
+      std::string expected_location = expected_dex_file->GetBaseLocation();
+      UniqueCPtr<const char[]> expected_real_location(
+          realpath(expected_location.c_str(), nullptr));
+      ASSERT_TRUE(expected_real_location != nullptr) << expected_location;
+      expected_location.assign(expected_real_location.get());
+      expected_location += DexFile::GetMultiDexSuffix(expected_dex_file->GetLocation());
 
-        ASSERT_EQ(expected_location, opened_dex_file->GetLocation());
-        ASSERT_EQ(expected_dex_file->GetLocationChecksum(), opened_dex_file->GetLocationChecksum());
-
-        std::string class_path_location = info.classpath[k];
-        UniqueCPtr<const char[]> class_path_location_real(
-            realpath(class_path_location.c_str(), nullptr));
-        ASSERT_TRUE(class_path_location_real != nullptr);
-        class_path_location.assign(class_path_location_real.get());
-        ASSERT_EQ(class_path_location, opened_dex_file->GetBaseLocation());
-      }
+      ASSERT_EQ(expected_location, opened_dex_file->GetLocation());
+      ASSERT_EQ(expected_dex_file->GetLocationChecksum(), opened_dex_file->GetLocationChecksum());
+      ASSERT_EQ(info.classpath[k], opened_dex_file->GetLocation());
     }
   }
 
@@ -148,6 +138,11 @@
     }
   }
 
+  void PretendContextOpenedDexFiles(ClassLoaderContext* context) {
+    context->dex_files_open_attempted_ = true;
+    context->dex_files_open_result_ = true;
+  }
+
  private:
   void VerifyClassLoaderInfo(ClassLoaderContext* context,
                              size_t index,
@@ -167,11 +162,9 @@
                                     ClassLoaderContext::ClassLoaderType type,
                                     const std::string& test_name) {
     std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles(test_name.c_str());
-    std::vector<std::vector<std::unique_ptr<const DexFile>>*> all_dex_files;
-    all_dex_files.push_back(&dex_files);
 
     VerifyClassLoaderInfo(context, index, type, GetTestDexFileName(test_name.c_str()));
-    VerifyOpenDexFiles(context, index, all_dex_files);
+    VerifyOpenDexFiles(context, index, &dex_files);
   }
 };
 
@@ -242,11 +235,8 @@
 
 TEST_F(ClassLoaderContextTest, OpenValidDexFiles) {
   std::string multidex_name = GetTestDexFileName("MultiDex");
-  std::vector<std::unique_ptr<const DexFile>> multidex_files = OpenTestDexFiles("MultiDex");
   std::string myclass_dex_name = GetTestDexFileName("MyClass");
-  std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
   std::string dex_name = GetTestDexFileName("Main");
-  std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles("Main");
 
   std::unique_ptr<ClassLoaderContext> context =
       ClassLoaderContext::Create(
@@ -256,14 +246,16 @@
   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, /*classpath_dir*/ ""));
 
   VerifyContextSize(context.get(), 2);
-  std::vector<std::vector<std::unique_ptr<const DexFile>>*> all_dex_files0;
-  all_dex_files0.push_back(&multidex_files);
-  all_dex_files0.push_back(&myclass_dex_files);
-  std::vector<std::vector<std::unique_ptr<const DexFile>>*> all_dex_files1;
-  all_dex_files1.push_back(&dex_files);
 
-  VerifyOpenDexFiles(context.get(), 0, all_dex_files0);
-  VerifyOpenDexFiles(context.get(), 1, all_dex_files1);
+  std::vector<std::unique_ptr<const DexFile>> all_dex_files0 = OpenTestDexFiles("MultiDex");
+  std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
+  for (size_t i = 0; i < myclass_dex_files.size(); i++) {
+    all_dex_files0.emplace_back(myclass_dex_files[i].release());
+  }
+  VerifyOpenDexFiles(context.get(), 0, &all_dex_files0);
+
+  std::vector<std::unique_ptr<const DexFile>> all_dex_files1 = OpenTestDexFiles("Main");
+  VerifyOpenDexFiles(context.get(), 1, &all_dex_files1);
 }
 
 class ScratchSymLink {
@@ -296,11 +288,10 @@
   ASSERT_TRUE(context->OpenDexFiles(InstructionSet::kArm, /*classpath_dir*/ ""));
 
   VerifyContextSize(context.get(), 1);
-  std::vector<std::vector<std::unique_ptr<const DexFile>>*> all_dex_files0;
-  std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
-  all_dex_files0.push_back(&myclass_dex_files);
 
-  VerifyOpenDexFiles(context.get(), 0, all_dex_files0);
+  std::vector<std::unique_ptr<const DexFile>> myclass_dex_files = OpenTestDexFiles("MyClass");
+
+  VerifyOpenDexFiles(context.get(), 0, &myclass_dex_files);
 }
 
 TEST_F(ClassLoaderContextTest, OpenInvalidDexFilesMix) {
@@ -552,6 +543,9 @@
 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatch) {
   std::string context_spec = "PCL[a.dex*123:b.dex*456];DLC[c.dex*890]";
   std::unique_ptr<ClassLoaderContext> context = ParseContextWithChecksums(context_spec);
+  // Pretend that we successfully open the dex files to pass the DCHECKS.
+  // (as it's much easier to test all the corner cases without relying on actual dex files).
+  PretendContextOpenedDexFiles(context.get());
 
   VerifyContextSize(context.get(), 2);
   VerifyClassLoaderPCL(context.get(), 0, "a.dex:b.dex");
@@ -589,7 +583,17 @@
 
   std::unique_ptr<ClassLoaderContext> context = CreateContextForClassLoader(class_loader_d);
 
-  ASSERT_TRUE(context->VerifyClassLoaderContextMatch(context->EncodeContextForOatFile("")));
+  std::string context_with_no_base_dir = context->EncodeContextForOatFile("");
+  ASSERT_TRUE(context->VerifyClassLoaderContextMatch(context_with_no_base_dir));
+
+  std::string dex_location = GetTestDexFileName("ForClassLoaderA");
+  size_t pos = dex_location.rfind('/');
+  ASSERT_NE(std::string::npos, pos);
+  std::string parent = dex_location.substr(0, pos);
+
+  std::string context_with_base_dir = context->EncodeContextForOatFile(parent);
+  ASSERT_NE(context_with_base_dir, context_with_no_base_dir);
+  ASSERT_TRUE(context->VerifyClassLoaderContextMatch(context_with_base_dir));
 }
 
 TEST_F(ClassLoaderContextTest, VerifyClassLoaderContextMatchAfterEncodingMultidex) {
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 6d4f77b..036f912 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -1251,44 +1251,6 @@
       CHECK(called != nullptr) << orig_called->PrettyMethod() << " "
                                << mirror::Object::PrettyTypeOf(receiver) << " "
                                << invoke_type << " " << orig_called->GetVtableIndex();
-
-      // We came here because of sharpening. Ensure the dex cache is up-to-date on the method index
-      // of the sharpened method avoiding dirtying the dex cache if possible.
-      // Note, called_method.dex_method_index references the dex method before the
-      // FindVirtualMethodFor... This is ok for FindDexMethodIndexInOtherDexFile that only cares
-      // about the name and signature.
-      uint32_t update_dex_cache_method_index = called->GetDexMethodIndex();
-      if (!called->HasSameDexCacheResolvedMethods(caller, kRuntimePointerSize)) {
-        // Calling from one dex file to another, need to compute the method index appropriate to
-        // the caller's dex file. Since we get here only if the original called was a runtime
-        // method, we've got the correct dex_file and a dex_method_idx from above.
-        DCHECK(!called_method_known_on_entry);
-        DCHECK_EQ(caller->GetDexFile(), called_method.dex_file);
-        const DexFile* caller_dex_file = called_method.dex_file;
-        uint32_t caller_method_name_and_sig_index = called_method.dex_method_index;
-        update_dex_cache_method_index =
-            called->FindDexMethodIndexInOtherDexFile(*caller_dex_file,
-                                                     caller_method_name_and_sig_index);
-      }
-      if ((update_dex_cache_method_index != DexFile::kDexNoIndex) &&
-          (caller->GetDexCacheResolvedMethod(
-              update_dex_cache_method_index, kRuntimePointerSize) != called)) {
-        caller->SetDexCacheResolvedMethod(update_dex_cache_method_index,
-                                          called,
-                                          kRuntimePointerSize);
-      }
-    } else if (invoke_type == kStatic) {
-      const auto called_dex_method_idx = called->GetDexMethodIndex();
-      // For static invokes, we may dispatch to the static method in the superclass but resolve
-      // using the subclass. To prevent getting slow paths on each invoke, we force set the
-      // resolved method for the super class dex method index if we are in the same dex file.
-      // b/19175856
-      if (called->GetDexFile() == called_method.dex_file &&
-          called_method.dex_method_index != called_dex_method_idx) {
-        called->GetDexCache()->SetResolvedMethod(called_dex_method_idx,
-                                                 called,
-                                                 kRuntimePointerSize);
-      }
     }
 
     // Ensure that the called method's class is initialized.
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index f1685b2..6129181 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -132,10 +132,6 @@
 // Dump the rosalloc stats on SIGQUIT.
 static constexpr bool kDumpRosAllocStatsOnSigQuit = false;
 
-// Extra added to the heap growth multiplier. Used to adjust the GC ergonomics for the read barrier
-// config.
-static constexpr double kExtraHeapGrowthMultiplier = kUseReadBarrier ? 1.0 : 0.0;
-
 static const char* kRegionSpaceName = "main space (region space)";
 
 // If true, we log all GCs in the both the foreground and background. Used for debugging.
@@ -255,8 +251,7 @@
       min_free_(min_free),
       max_free_(max_free),
       target_utilization_(target_utilization),
-      foreground_heap_growth_multiplier_(
-          foreground_heap_growth_multiplier + kExtraHeapGrowthMultiplier),
+      foreground_heap_growth_multiplier_(foreground_heap_growth_multiplier),
       total_wait_time_(0),
       verify_object_mode_(kVerifyObjectModeDisabled),
       disable_moving_gc_count_(0),
@@ -3428,7 +3423,7 @@
 
 double Heap::HeapGrowthMultiplier() const {
   // If we don't care about pause times we are background, so return 1.0.
-  if (!CareAboutPauseTimes() || IsLowMemoryMode()) {
+  if (!CareAboutPauseTimes()) {
     return 1.0;
   }
   return foreground_heap_growth_multiplier_;
diff --git a/runtime/image.cc b/runtime/image.cc
index 7d0a709..e3a4060 100644
--- a/runtime/image.cc
+++ b/runtime/image.cc
@@ -149,6 +149,19 @@
   return os << "size=" << section.Size() << " range=" << section.Offset() << "-" << section.End();
 }
 
+void ImageHeader::VisitObjects(ObjectVisitor* visitor,
+                               uint8_t* base,
+                               PointerSize pointer_size) const {
+  DCHECK_EQ(pointer_size, GetPointerSize());
+  const ImageSection& objects = GetObjectsSection();
+  static const size_t kStartPos = RoundUp(sizeof(ImageHeader), kObjectAlignment);
+  for (size_t pos = kStartPos; pos < objects.Size(); ) {
+    mirror::Object* object = reinterpret_cast<mirror::Object*>(base + objects.Offset() + pos);
+    visitor->Visit(object);
+    pos += RoundUp(object->SizeOf(), kObjectAlignment);
+  }
+}
+
 void ImageHeader::VisitPackedArtFields(ArtFieldVisitor* visitor, uint8_t* base) const {
   const ImageSection& fields = GetFieldsSection();
   for (size_t pos = 0; pos < fields.Size(); ) {
diff --git a/runtime/image.h b/runtime/image.h
index 6c76f49..7d3be03 100644
--- a/runtime/image.h
+++ b/runtime/image.h
@@ -28,6 +28,13 @@
 class ArtField;
 class ArtMethod;
 
+class ObjectVisitor {
+ public:
+  virtual ~ObjectVisitor() {}
+
+  virtual void Visit(mirror::Object* object) = 0;
+};
+
 class ArtMethodVisitor {
  public:
   virtual ~ArtMethodVisitor() {}
@@ -216,6 +223,10 @@
 
   const ImageSection& GetImageSection(ImageSections index) const;
 
+  const ImageSection& GetObjectsSection() const {
+    return GetImageSection(kSectionObjects);
+  }
+
   const ImageSection& GetMethodsSection() const {
     return GetImageSection(kSectionArtMethods);
   }
@@ -278,6 +289,13 @@
     return boot_image_size_ != 0u;
   }
 
+  // Visit mirror::Objects in the section starting at base.
+  // TODO: Delete base parameter if it is always equal to GetImageBegin.
+  void VisitObjects(ObjectVisitor* visitor,
+                    uint8_t* base,
+                    PointerSize pointer_size) const
+      REQUIRES_SHARED(Locks::mutator_lock_);
+
   // Visit ArtMethods in the section starting at base. Includes runtime methods.
   // TODO: Delete base parameter if it is always equal to GetImageBegin.
   void VisitPackedArtMethods(ArtMethodVisitor* visitor,
diff --git a/runtime/jit/profile_compilation_info.cc b/runtime/jit/profile_compilation_info.cc
index ee2c44a..77efce2 100644
--- a/runtime/jit/profile_compilation_info.cc
+++ b/runtime/jit/profile_compilation_info.cc
@@ -140,8 +140,7 @@
   if (data == nullptr) {
     return false;
   }
-  data->AddMethod(flags, ref.dex_method_index);
-  return true;
+  return data->AddMethod(flags, ref.dex_method_index);
 }
 
 bool ProfileCompilationInfo::AddMethodIndex(MethodHotness::Flag flags,
@@ -155,8 +154,7 @@
   if (data == nullptr) {
     return false;
   }
-  data->AddMethod(flags, method_idx);
-  return true;
+  return data->AddMethod(flags, method_idx);
 }
 
 bool ProfileCompilationInfo::AddMethods(const std::vector<ProfileMethodInfo>& methods) {
@@ -557,7 +555,14 @@
   // This should always be the case since since the cache map is managed by ProfileCompilationInfo.
   DCHECK_EQ(profile_key, result->profile_key);
   DCHECK_EQ(profile_index, result->profile_index);
-  DCHECK_EQ(num_method_ids, result->num_method_ids);
+
+  if (num_method_ids != result->num_method_ids) {
+    // This should not happen... added to help investigating b/65812889.
+    LOG(ERROR) << "num_method_ids mismatch for dex " << profile_key
+        << ", expected=" << num_method_ids
+        << ", actual=" << result->num_method_ids;
+    return nullptr;
+  }
 
   return result;
 }
@@ -1251,9 +1256,9 @@
   DexFileData* dex_data = GetOrAddDexFileData(method_ref.dex_file);
   if (dex_data != nullptr) {
     // TODO: Add inline caches.
-    dex_data->AddMethod(static_cast<MethodHotness::Flag>(hotness.GetFlags()),
-                        method_ref.dex_method_index);
-    return true;
+    return dex_data->AddMethod(
+        static_cast<MethodHotness::Flag>(hotness.GetFlags()),
+        method_ref.dex_method_index);
   }
   return false;
 }
@@ -1618,7 +1623,12 @@
 }
 
 // Mark a method as executed at least once.
-void ProfileCompilationInfo::DexFileData::AddMethod(MethodHotness::Flag flags, size_t index) {
+bool ProfileCompilationInfo::DexFileData::AddMethod(MethodHotness::Flag flags, size_t index) {
+  if (index >= num_method_ids) {
+    LOG(ERROR) << "Invalid method index " << index << ". num_method_ids=" << num_method_ids;
+    return false;
+  }
+
   if ((flags & MethodHotness::kFlagStartup) != 0) {
     method_bitmap.StoreBit(MethodBitIndex(/*startup*/ true, index), /*value*/ true);
   }
@@ -1630,6 +1640,7 @@
         index,
         InlineCacheMap(std::less<uint16_t>(), arena_->Adapter(kArenaAllocProfile)));
   }
+  return true;
 }
 
 ProfileCompilationInfo::MethodHotness ProfileCompilationInfo::DexFileData::GetHotnessInfo(
diff --git a/runtime/jit/profile_compilation_info.h b/runtime/jit/profile_compilation_info.h
index 4ab8be8..29fa79c 100644
--- a/runtime/jit/profile_compilation_info.h
+++ b/runtime/jit/profile_compilation_info.h
@@ -280,7 +280,9 @@
     }
     for (Iterator it = index_begin; it != index_end; ++it) {
       DCHECK_LT(*it, data->num_method_ids);
-      data->AddMethod(flags, *it);
+      if (!data->AddMethod(flags, *it)) {
+        return false;
+      }
     }
     return true;
   }
@@ -428,7 +430,7 @@
     }
 
     // Mark a method as executed at least once.
-    void AddMethod(MethodHotness::Flag flags, size_t index);
+    bool AddMethod(MethodHotness::Flag flags, size_t index);
 
     void MergeBitmap(const DexFileData& other) {
       DCHECK_EQ(bitmap_storage.size(), other.bitmap_storage.size());
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index 07dfb65..d40e6d9 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -493,6 +493,8 @@
   if (oat_file_assistant.IsInBootClassPath()) {
     return OatFileAssistant::kNoDexOptNeeded;
   }
+
+  // TODO(calin): Extend DexFile.getDexOptNeeded to accept the class loader context. b/62269291.
   return oat_file_assistant.GetDexOptNeeded(filter, profile_changed, downgrade);
 }
 
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index 8688205..8b141173 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -74,9 +74,6 @@
 // For debugging, Open will print DlOpen error message if set to true.
 static constexpr bool kPrintDlOpenErrorMessage = false;
 
-// If true, we advise the kernel about dex file mem map accesses.
-static constexpr bool kMadviseDexFileAccesses = true;
-
 // Note for OatFileBase and descendents:
 //
 // These are used in OatFile::Open to try all our loaders.
@@ -1498,20 +1495,19 @@
 
 // Madvise the dex file based on the state we are moving to.
 void OatDexFile::MadviseDexFile(const DexFile& dex_file, MadviseState state) {
-  const bool low_ram = Runtime::Current()->GetHeap()->IsLowMemoryMode();
+  Runtime* const runtime = Runtime::Current();
+  const bool low_ram = runtime->GetHeap()->IsLowMemoryMode();
   // TODO: Also do madvise hints for non low ram devices.
-  if (!kMadviseDexFileAccesses || !low_ram) {
+  if (!low_ram) {
     return;
   }
-  if (state == MadviseState::kMadviseStateAtLoad) {
-    if (low_ram) {
-      // Default every dex file to MADV_RANDOM when its loaded by default for low ram devices.
-      // Other devices have enough page cache to get performance benefits from loading more pages
-      // into the page cache.
-      MadviseLargestPageAlignedRegion(dex_file.Begin(),
-                                      dex_file.Begin() + dex_file.Size(),
-                                      MADV_RANDOM);
-    }
+  if (state == MadviseState::kMadviseStateAtLoad && runtime->MAdviseRandomAccess()) {
+    // Default every dex file to MADV_RANDOM when its loaded by default for low ram devices.
+    // Other devices have enough page cache to get performance benefits from loading more pages
+    // into the page cache.
+    MadviseLargestPageAlignedRegion(dex_file.Begin(),
+                                    dex_file.Begin() + dex_file.Size(),
+                                    MADV_RANDOM);
   }
   const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
   if (oat_dex_file != nullptr) {
@@ -1619,6 +1615,10 @@
   return GetOatHeader().GetCompilerFilter();
 }
 
+std::string OatFile::GetClassLoaderContext() const {
+  return GetOatHeader().GetStoreValueByKey(OatHeader::kClassPathKey);
+};
+
 OatFile::OatClass OatFile::FindOatClass(const DexFile& dex_file,
                                         uint16_t class_def_idx,
                                         bool* found) {
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index 9a7fe51..0a05b29 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -115,6 +115,8 @@
 
   CompilerFilter::Filter GetCompilerFilter() const;
 
+  std::string GetClassLoaderContext() const;
+
   const std::string& GetLocation() const {
     return location_;
   }
diff --git a/runtime/oat_file_assistant.cc b/runtime/oat_file_assistant.cc
index 5814df9..475a1c2 100644
--- a/runtime/oat_file_assistant.cc
+++ b/runtime/oat_file_assistant.cc
@@ -190,9 +190,13 @@
 
 int OatFileAssistant::GetDexOptNeeded(CompilerFilter::Filter target,
                                       bool profile_changed,
-                                      bool downgrade) {
+                                      bool downgrade,
+                                      ClassLoaderContext* class_loader_context) {
   OatFileInfo& info = GetBestInfo();
-  DexOptNeeded dexopt_needed = info.GetDexOptNeeded(target, profile_changed, downgrade);
+  DexOptNeeded dexopt_needed = info.GetDexOptNeeded(target,
+                                                    profile_changed,
+                                                    downgrade,
+                                                    class_loader_context);
   if (info.IsOatLocation() || dexopt_needed == kDex2OatFromScratch) {
     return dexopt_needed;
   }
@@ -227,7 +231,7 @@
 
 OatFileAssistant::ResultOfAttemptToUpdate
 OatFileAssistant::MakeUpToDate(bool profile_changed,
-                               const std::string& class_loader_context,
+                               ClassLoaderContext* class_loader_context,
                                std::string* error_msg) {
   CompilerFilter::Filter target;
   if (!GetRuntimeCompilerFilterOption(&target, error_msg)) {
@@ -245,7 +249,8 @@
   //   - however, MakeUpToDate will not always succeed (e.g. for primary apks, or for dex files
   //     loaded in other processes). So it boils down to how far do we want to complicate
   //     the logic in order to enable the use of oat files. Maybe its time to try simplify it.
-  switch (info.GetDexOptNeeded(target, profile_changed, /*downgrade*/ false)) {
+  switch (info.GetDexOptNeeded(
+        target, profile_changed, /*downgrade*/ false, class_loader_context)) {
     case kNoDexOptNeeded:
       return kUpdateSucceeded;
 
@@ -640,10 +645,34 @@
   return true;
 }
 
+class Dex2oatFileWrapper {
+ public:
+  explicit Dex2oatFileWrapper(File* file)
+      : file_(file),
+        unlink_file_at_destruction_(true) {
+  }
+
+  ~Dex2oatFileWrapper() {
+    if (unlink_file_at_destruction_ && (file_ != nullptr)) {
+      file_->Erase(/*unlink*/ true);
+    }
+  }
+
+  File* GetFile() { return file_.get(); }
+
+  void DisableUnlinkAtDestruction() {
+    unlink_file_at_destruction_ = false;
+  };
+
+ private:
+  std::unique_ptr<File> file_;
+  bool unlink_file_at_destruction_;
+};
+
 OatFileAssistant::ResultOfAttemptToUpdate OatFileAssistant::GenerateOatFileNoChecks(
       OatFileAssistant::OatFileInfo& info,
       CompilerFilter::Filter filter,
-      const std::string& class_loader_context,
+      const ClassLoaderContext* class_loader_context,
       std::string* error_msg) {
   CHECK(error_msg != nullptr);
 
@@ -685,8 +714,9 @@
       (dex_path_stat.st_mode & S_IRGRP) |
       (dex_path_stat.st_mode & S_IROTH);
 
-  std::unique_ptr<File> vdex_file(OS::CreateEmptyFile(vdex_file_name.c_str()));
-  if (vdex_file.get() == nullptr) {
+  Dex2oatFileWrapper vdex_file_wrapper(OS::CreateEmptyFile(vdex_file_name.c_str()));
+  File* vdex_file = vdex_file_wrapper.GetFile();
+  if (vdex_file == nullptr) {
     *error_msg = "Generation of oat file " + oat_file_name
       + " not attempted because the vdex file " + vdex_file_name
       + " could not be opened.";
@@ -700,8 +730,9 @@
     return kUpdateNotAttempted;
   }
 
-  std::unique_ptr<File> oat_file(OS::CreateEmptyFile(oat_file_name.c_str()));
-  if (oat_file.get() == nullptr) {
+  Dex2oatFileWrapper oat_file_wrapper(OS::CreateEmptyFile(oat_file_name.c_str()));
+  File* oat_file = oat_file_wrapper.GetFile();
+  if (oat_file == nullptr) {
     *error_msg = "Generation of oat file " + oat_file_name
       + " not attempted because the oat file could not be created.";
     return kUpdateNotAttempted;
@@ -710,7 +741,6 @@
   if (fchmod(oat_file->Fd(), file_mode) != 0) {
     *error_msg = "Generation of oat file " + oat_file_name
       + " not attempted because the oat file could not be made world readable.";
-    oat_file->Erase();
     return kUpdateNotAttempted;
   }
 
@@ -720,32 +750,31 @@
   args.push_back("--oat-fd=" + std::to_string(oat_file->Fd()));
   args.push_back("--oat-location=" + oat_file_name);
   args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(filter));
-  args.push_back("--class-loader-context=" + class_loader_context);
+  const std::string dex2oat_context = class_loader_context == nullptr
+        ? OatFile::kSpecialSharedLibrary
+        : class_loader_context->EncodeContextForDex2oat(/*base_dir*/ "");
+  args.push_back("--class-loader-context=" + dex2oat_context);
 
   if (!Dex2Oat(args, error_msg)) {
-    // Manually delete the oat and vdex files. This ensures there is no garbage
-    // left over if the process unexpectedly died.
-    vdex_file->Erase();
-    unlink(vdex_file_name.c_str());
-    oat_file->Erase();
-    unlink(oat_file_name.c_str());
     return kUpdateFailed;
   }
 
   if (vdex_file->FlushCloseOrErase() != 0) {
     *error_msg = "Unable to close vdex file " + vdex_file_name;
-    unlink(vdex_file_name.c_str());
     return kUpdateFailed;
   }
 
   if (oat_file->FlushCloseOrErase() != 0) {
     *error_msg = "Unable to close oat file " + oat_file_name;
-    unlink(oat_file_name.c_str());
     return kUpdateFailed;
   }
 
   // Mark that the odex file has changed and we should try to reload.
   info.Reset();
+  // We have compiled successfully. Disable the auto-unlink.
+  vdex_file_wrapper.DisableUnlinkAtDestruction();
+  oat_file_wrapper.DisableUnlinkAtDestruction();
+
   return kUpdateSucceeded;
 }
 
@@ -1016,31 +1045,40 @@
 }
 
 OatFileAssistant::DexOptNeeded OatFileAssistant::OatFileInfo::GetDexOptNeeded(
-    CompilerFilter::Filter target, bool profile_changed, bool downgrade) {
+    CompilerFilter::Filter target,
+    bool profile_changed,
+    bool downgrade,
+    ClassLoaderContext* context) {
+
   bool compilation_desired = CompilerFilter::IsAotCompilationEnabled(target);
   bool filter_okay = CompilerFilterIsOkay(target, profile_changed, downgrade);
+  bool class_loader_context_okay = ClassLoaderContextIsOkay(context);
 
-  if (filter_okay && Status() == kOatUpToDate) {
-    // The oat file is in good shape as is.
-    return kNoDexOptNeeded;
-  }
+  // Only check the filter and relocation if the class loader context is ok.
+  // If it is not, we will return kDex2OatFromScratch as the compilation needs to be redone.
+  if (class_loader_context_okay) {
+    if (filter_okay && Status() == kOatUpToDate) {
+      // The oat file is in good shape as is.
+      return kNoDexOptNeeded;
+    }
 
-  if (filter_okay && !compilation_desired && Status() == kOatRelocationOutOfDate) {
-    // If no compilation is desired, then it doesn't matter if the oat
-    // file needs relocation. It's in good shape as is.
-    return kNoDexOptNeeded;
-  }
+    if (filter_okay && !compilation_desired && Status() == kOatRelocationOutOfDate) {
+      // If no compilation is desired, then it doesn't matter if the oat
+      // file needs relocation. It's in good shape as is.
+      return kNoDexOptNeeded;
+    }
 
-  if (filter_okay && Status() == kOatRelocationOutOfDate) {
-    return kDex2OatForRelocation;
-  }
+    if (filter_okay && Status() == kOatRelocationOutOfDate) {
+      return kDex2OatForRelocation;
+    }
 
-  if (IsUseable()) {
-    return kDex2OatForFilter;
-  }
+    if (IsUseable()) {
+      return kDex2OatForFilter;
+    }
 
-  if (Status() == kOatBootImageOutOfDate) {
-    return kDex2OatForBootImage;
+    if (Status() == kOatBootImageOutOfDate) {
+      return kDex2OatForBootImage;
+    }
   }
 
   if (oat_file_assistant_->HasOriginalDexFiles()) {
@@ -1090,6 +1128,36 @@
     CompilerFilter::IsAsGoodAs(current, target);
 }
 
+bool OatFileAssistant::OatFileInfo::ClassLoaderContextIsOkay(ClassLoaderContext* context) {
+  if (context == nullptr) {
+    VLOG(oat) << "ClassLoaderContext check ignored: null context";
+    return true;
+  }
+
+  const OatFile* file = GetFile();
+  if (file == nullptr) {
+    return false;
+  }
+
+  size_t dir_index = file->GetLocation().rfind('/');
+  std::string classpath_dir = (dir_index != std::string::npos)
+      ? file->GetLocation().substr(0, dir_index)
+      : "";
+
+  if (!context->OpenDexFiles(oat_file_assistant_->isa_, classpath_dir)) {
+    VLOG(oat) << "ClassLoaderContext check failed: dex files from the context could not be opened";
+    return false;
+  }
+
+  bool result = context->VerifyClassLoaderContextMatch(file->GetClassLoaderContext());
+  if (!result) {
+    VLOG(oat) << "ClassLoaderContext check failed. Context was "
+              << file->GetClassLoaderContext()
+              << ". The expected context is " << context->EncodeContextForOatFile(classpath_dir);
+  }
+  return result;
+}
+
 bool OatFileAssistant::OatFileInfo::IsExecutable() {
   const OatFile* file = GetFile();
   return (file != nullptr && file->IsExecutable());
diff --git a/runtime/oat_file_assistant.h b/runtime/oat_file_assistant.h
index 5eec943..6dc3c19 100644
--- a/runtime/oat_file_assistant.h
+++ b/runtime/oat_file_assistant.h
@@ -26,6 +26,7 @@
 #include "base/scoped_flock.h"
 #include "base/unix_file/fd_file.h"
 #include "compiler_filter.h"
+#include "class_loader_context.h"
 #include "oat_file.h"
 #include "os.h"
 
@@ -164,7 +165,8 @@
   // the oat file in the odex location.
   int GetDexOptNeeded(CompilerFilter::Filter target_compiler_filter,
                       bool profile_changed = false,
-                      bool downgrade = false);
+                      bool downgrade = false,
+                      ClassLoaderContext* context = nullptr);
 
   // Returns true if there is up-to-date code for this dex location,
   // irrespective of the compiler filter of the up-to-date code.
@@ -194,7 +196,7 @@
   // to a string describing why there was a failure or the update was not
   // attempted. error_msg must not be null.
   ResultOfAttemptToUpdate MakeUpToDate(bool profile_changed,
-                                       const std::string& class_loader_context,
+                                       ClassLoaderContext* class_loader_context,
                                        std::string* error_msg);
 
   // Returns an oat file that can be used for loading dex files.
@@ -330,7 +332,8 @@
     // compiler filter.
     DexOptNeeded GetDexOptNeeded(CompilerFilter::Filter target_compiler_filter,
                                  bool profile_changed,
-                                 bool downgrade);
+                                 bool downgrade,
+                                 ClassLoaderContext* context);
 
     // Returns the loaded file.
     // Loads the file if needed. Returns null if the file failed to load.
@@ -367,6 +370,8 @@
     // compiler filter.
     bool CompilerFilterIsOkay(CompilerFilter::Filter target, bool profile_changed, bool downgrade);
 
+    bool ClassLoaderContextIsOkay(ClassLoaderContext* context);
+
     // Release the loaded oat file.
     // Returns null if the oat file hasn't been loaded.
     //
@@ -404,7 +409,7 @@
   // attempted. error_msg must not be null.
   ResultOfAttemptToUpdate GenerateOatFileNoChecks(OatFileInfo& info,
                                                   CompilerFilter::Filter target,
-                                                  const std::string& class_loader_context,
+                                                  const ClassLoaderContext* class_loader_context,
                                                   std::string* error_msg);
 
   // Return info for the best oat file.
diff --git a/runtime/oat_file_assistant_test.cc b/runtime/oat_file_assistant_test.cc
index ea665d9..0ad26d6 100644
--- a/runtime/oat_file_assistant_test.cc
+++ b/runtime/oat_file_assistant_test.cc
@@ -36,6 +36,7 @@
 namespace art {
 
 static const std::string kSpecialSharedLibrary = "&";
+static ClassLoaderContext* kSpecialSharedLibraryContext = nullptr;
 
 class OatFileAssistantTest : public DexoptTest {};
 
@@ -117,7 +118,7 @@
   // Trying to make the oat file up to date should not fail or crash.
   std::string error_msg;
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-          oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg));
+          oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg));
 
   // Trying to get the best oat file should fail, but not crash.
   std::unique_ptr<OatFile> oat_file = oat_file_assistant.GetBestOatFile();
@@ -770,7 +771,7 @@
   std::string error_msg;
   Runtime::Current()->AddCompilerOption("--compiler-filter=speed");
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg)) <<
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg)) <<
           error_msg;
 
   EXPECT_EQ(OatFileAssistant::kNoDexOptNeeded,
@@ -951,7 +952,7 @@
   // We should get kUpdateSucceeded from MakeUpToDate since there's nothing
   // that can be done in this situation.
   ASSERT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg));
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg));
 
   // Verify it didn't create an oat in the default location (dalvik-cache).
   OatFileAssistant ofm(dex_location.c_str(), kRuntimeISA, false);
@@ -1030,7 +1031,7 @@
   std::string error_msg;
   Runtime::Current()->AddCompilerOption("--compiler-filter=speed");
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg));
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg));
   EXPECT_TRUE(error_msg.empty());
 }
 
@@ -1177,7 +1178,7 @@
   std::string error_msg;
   Runtime::Current()->AddCompilerOption("--compiler-filter=quicken");
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg)) <<
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg)) <<
           error_msg;
   EXPECT_EQ(-OatFileAssistant::kNoDexOptNeeded,
       oat_file_assistant.GetDexOptNeeded(CompilerFilter::kQuicken));
@@ -1186,7 +1187,7 @@
 
   Runtime::Current()->AddCompilerOption("--compiler-filter=speed");
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg))
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg))
           << error_msg;
   EXPECT_EQ(OatFileAssistant::kNoDexOptNeeded,
       oat_file_assistant.GetDexOptNeeded(CompilerFilter::kQuicken));
@@ -1195,7 +1196,7 @@
 
   Runtime::Current()->AddCompilerOption("--compiler-filter=bogus");
   EXPECT_EQ(OatFileAssistant::kUpdateNotAttempted,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg));
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg));
 }
 
 TEST(OatFileAssistantUtilsTest, DexLocationToOdexFilename) {
@@ -1255,7 +1256,7 @@
       OatFileAssistant::kDefaultCompilerFilterForDexLoading;
   std::string error_msg;
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded,
-      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg)) <<
+      oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg)) <<
           error_msg;
   EXPECT_EQ(-OatFileAssistant::kNoDexOptNeeded,
             oat_file_assistant.GetDexOptNeeded(default_filter));
@@ -1273,7 +1274,7 @@
   const CompilerFilter::Filter default_filter =
       OatFileAssistant::kDefaultCompilerFilterForDexLoading;
   std::string error_msg;
-  int status = oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibrary, &error_msg);
+  int status = oat_file_assistant.MakeUpToDate(false, kSpecialSharedLibraryContext, &error_msg);
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded, status) << error_msg;
   EXPECT_EQ(-OatFileAssistant::kNoDexOptNeeded,
       oat_file_assistant.GetDexOptNeeded(default_filter));
@@ -1295,19 +1296,52 @@
       OatFileAssistant::kDefaultCompilerFilterForDexLoading;
   std::string error_msg;
   std::string context_str = "PCL[" + context_location + "]";
-  int status = oat_file_assistant.MakeUpToDate(false, context_str, &error_msg);
+  std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_str);
+  ASSERT_TRUE(context != nullptr);
+  ASSERT_TRUE(context->OpenDexFiles(kRuntimeISA, ""));
+
+  int status = oat_file_assistant.MakeUpToDate(false, context.get(), &error_msg);
   EXPECT_EQ(OatFileAssistant::kUpdateSucceeded, status) << error_msg;
   EXPECT_EQ(-OatFileAssistant::kNoDexOptNeeded,
-  oat_file_assistant.GetDexOptNeeded(default_filter));
+            oat_file_assistant.GetDexOptNeeded(default_filter, false, false, context.get()));
+
   std::unique_ptr<OatFile> oat_file = oat_file_assistant.GetBestOatFile();
   EXPECT_NE(nullptr, oat_file.get());
-  std::unique_ptr<ClassLoaderContext> context =
-      ClassLoaderContext::Create(context_str);
-  context->OpenDexFiles(kRuntimeISA, "");
   EXPECT_EQ(context->EncodeContextForOatFile(""),
       oat_file->GetOatHeader().GetStoreValueByKey(OatHeader::kClassPathKey));
 }
 
+TEST_F(OatFileAssistantTest, GetDexOptNeededWithOutOfDateContext) {
+  std::string dex_location = GetScratchDir() + "/TestDex.jar";
+  std::string context_location = GetScratchDir() + "/ContextDex.jar";
+  Copy(GetDexSrc1(), dex_location);
+  Copy(GetDexSrc2(), context_location);
+
+  OatFileAssistant oat_file_assistant(dex_location.c_str(), kRuntimeISA, false);
+
+  const CompilerFilter::Filter default_filter =
+      OatFileAssistant::kDefaultCompilerFilterForDexLoading;
+  std::string error_msg;
+  std::string context_str = "PCL[" + context_location + "]";
+  std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_str);
+  ASSERT_TRUE(context != nullptr);
+  ASSERT_TRUE(context->OpenDexFiles(kRuntimeISA, ""));
+
+  int status = oat_file_assistant.MakeUpToDate(false, context.get(), &error_msg);
+  EXPECT_EQ(OatFileAssistant::kUpdateSucceeded, status) << error_msg;
+  EXPECT_EQ(-OatFileAssistant::kNoDexOptNeeded,
+            oat_file_assistant.GetDexOptNeeded(default_filter, false, false, context.get()));
+
+  // Update the context by overriding the jar file.
+  Copy(GetMultiDexSrc2(), context_location);
+  std::unique_ptr<ClassLoaderContext> updated_context = ClassLoaderContext::Create(context_str);
+  ASSERT_TRUE(updated_context != nullptr);
+  // DexOptNeeded should advise compilation from scratch.
+  EXPECT_EQ(OatFileAssistant::kDex2OatFromScratch,
+            oat_file_assistant.GetDexOptNeeded(
+                  default_filter, false, false, updated_context.get()));
+}
+
 // TODO: More Tests:
 //  * Test class linker falls back to unquickened dex for DexNoOat
 //  * Test class linker falls back to unquickened dex for MultiDexNoOat
diff --git a/runtime/oat_file_manager.cc b/runtime/oat_file_manager.cc
index 499f356..9b43a31 100644
--- a/runtime/oat_file_manager.cc
+++ b/runtime/oat_file_manager.cc
@@ -361,8 +361,7 @@
 
   // If the pat file loading context matches the context used during compilation then we accept
   // the oat file without addition checks
-  if (context->VerifyClassLoaderContextMatch(
-      oat_file->GetOatHeader().GetStoreValueByKey(OatHeader::kClassPathKey))) {
+  if (context->VerifyClassLoaderContextMatch(oat_file->GetClassLoaderContext())) {
     return false;
   }
 
@@ -426,12 +425,14 @@
     // Update the oat file on disk if we can, based on the --compiler-filter
     // option derived from the current runtime options.
     // This may fail, but that's okay. Best effort is all that matters here.
-
-    const std::string& dex2oat_context = context == nullptr
-        ? OatFile::kSpecialSharedLibrary
-        : context->EncodeContextForDex2oat(/*base_dir*/ "");
-    switch (oat_file_assistant.MakeUpToDate(
-        /*profile_changed*/false, dex2oat_context, /*out*/ &error_msg)) {
+    // TODO(calin): b/64530081 b/66984396. Pass a null context to verify and compile
+    // secondary dex files in isolation (and avoid to extract/verify the main apk
+    // if it's in the class path). Note this trades correctness for performance
+    // since the resulting slow down is unacceptable in some cases until b/64530081
+    // is fixed.
+    switch (oat_file_assistant.MakeUpToDate(/*profile_changed*/ false,
+                                            /*class_loader_context*/ nullptr,
+                                            /*out*/ &error_msg)) {
       case OatFileAssistant::kUpdateFailed:
         LOG(WARNING) << error_msg;
         break;
diff --git a/runtime/parsed_options.cc b/runtime/parsed_options.cc
index 1d524fd..5d2f3b2 100644
--- a/runtime/parsed_options.cc
+++ b/runtime/parsed_options.cc
@@ -121,7 +121,7 @@
           .WithType<double>().WithRange(0.1, 0.9)
           .IntoKey(M::HeapTargetUtilization)
       .Define("-XX:ForegroundHeapGrowthMultiplier=_")
-          .WithType<double>().WithRange(0.1, 1.0)
+          .WithType<double>().WithRange(0.1, 5.0)
           .IntoKey(M::ForegroundHeapGrowthMultiplier)
       .Define("-XX:ParallelGCThreads=_")
           .WithType<unsigned int>()
@@ -159,6 +159,10 @@
           .WithType<bool>()
           .WithValueMap({{"false", false}, {"true", true}})
           .IntoKey(M::DumpNativeStackOnSigQuit)
+      .Define("-XX:MadviseRandomAccess:_")
+          .WithType<bool>()
+          .WithValueMap({{"false", false}, {"true", true}})
+          .IntoKey(M::MadviseRandomAccess)
       .Define("-Xusejit:_")
           .WithType<bool>()
           .WithValueMap({{"false", false}, {"true", true}})
@@ -714,6 +718,7 @@
   UsageMessage(stream, "  -XX:LargeObjectSpace={disabled,map,freelist}\n");
   UsageMessage(stream, "  -XX:LargeObjectThreshold=N\n");
   UsageMessage(stream, "  -XX:DumpNativeStackOnSigQuit=booleanvalue\n");
+  UsageMessage(stream, "  -XX:MadviseRandomAccess:booleanvalue\n");
   UsageMessage(stream, "  -XX:SlowDebug={false,true}\n");
   UsageMessage(stream, "  -Xmethod-trace\n");
   UsageMessage(stream, "  -Xmethod-trace-file:filename");
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 216edd9..c855906 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -171,6 +171,11 @@
 static constexpr double kLowMemoryMaxLoadFactor = 0.8;
 static constexpr double kNormalMinLoadFactor = 0.4;
 static constexpr double kNormalMaxLoadFactor = 0.7;
+
+// Extra added to the default heap growth multiplier. Used to adjust the GC ergonomics for the read
+// barrier config.
+static constexpr double kExtraDefaultHeapGrowthMultiplier = kUseReadBarrier ? 1.0 : 0.0;
+
 Runtime* Runtime::instance_ = nullptr;
 
 struct TraceConfig {
@@ -416,6 +421,12 @@
       return;
     }
     Thread* self = Thread::Current();
+
+    // Dump all threads first and then the aborting thread. While this is counter the logical flow,
+    // it improves the chance of relevant data surviving in the Android logs.
+
+    DumpAllThreads(os, self);
+
     if (self == nullptr) {
       os << "(Aborting thread was not attached to runtime!)\n";
       DumpKernelStack(os, GetTid(), "  kernel: ", false);
@@ -431,7 +442,6 @@
         }
       }
     }
-    DumpAllThreads(os, self);
   }
 
   // No thread-safety analysis as we do explicitly test for holding the mutator lock.
@@ -1130,6 +1140,7 @@
   zygote_max_failed_boots_ = runtime_options.GetOrDefault(Opt::ZygoteMaxFailedBoots);
   experimental_flags_ = runtime_options.GetOrDefault(Opt::Experimental);
   is_low_memory_mode_ = runtime_options.Exists(Opt::LowMemoryMode);
+  madvise_random_access_ = runtime_options.GetOrDefault(Opt::MadviseRandomAccess);
 
   plugins_ = runtime_options.ReleaseOrDefault(Opt::Plugins);
   agents_ = runtime_options.ReleaseOrDefault(Opt::AgentPath);
@@ -1138,13 +1149,22 @@
   //   agents_.push_back(lib);
   // }
 
+  float foreground_heap_growth_multiplier;
+  if (is_low_memory_mode_ && !runtime_options.Exists(Opt::ForegroundHeapGrowthMultiplier)) {
+    // If low memory mode, use 1.0 as the multiplier by default.
+    foreground_heap_growth_multiplier = 1.0f;
+  } else {
+    foreground_heap_growth_multiplier =
+        runtime_options.GetOrDefault(Opt::ForegroundHeapGrowthMultiplier) +
+            kExtraDefaultHeapGrowthMultiplier;
+  }
   XGcOption xgc_option = runtime_options.GetOrDefault(Opt::GcOption);
   heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),
                        runtime_options.GetOrDefault(Opt::HeapGrowthLimit),
                        runtime_options.GetOrDefault(Opt::HeapMinFree),
                        runtime_options.GetOrDefault(Opt::HeapMaxFree),
                        runtime_options.GetOrDefault(Opt::HeapTargetUtilization),
-                       runtime_options.GetOrDefault(Opt::ForegroundHeapGrowthMultiplier),
+                       foreground_heap_growth_multiplier,
                        runtime_options.GetOrDefault(Opt::MemoryMaximumSize),
                        runtime_options.GetOrDefault(Opt::NonMovingSpaceCapacity),
                        runtime_options.GetOrDefault(Opt::Image),
diff --git a/runtime/runtime.h b/runtime/runtime.h
index c632089..5180acd 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -671,6 +671,12 @@
     return result;
   }
 
+  // Whether or not we use MADV_RANDOM on files that are thought to have random access patterns.
+  // This is beneficial for low RAM devices since it reduces page cache thrashing.
+  bool MAdviseRandomAccess() const {
+    return madvise_random_access_;
+  }
+
  private:
   static void InitPlatformSignalHandlers();
 
@@ -902,6 +908,10 @@
   // Whether or not we are on a low RAM device.
   bool is_low_memory_mode_;
 
+  // Whether or not we use MADV_RANDOM on files that are thought to have random access patterns.
+  // This is beneficial for low RAM devices since it reduces page cache thrashing.
+  bool madvise_random_access_;
+
   // Whether the application should run in safe mode, that is, interpreter only.
   bool safe_mode_;
 
diff --git a/runtime/runtime_options.def b/runtime/runtime_options.def
index 78a60fa..f8671a9 100644
--- a/runtime/runtime_options.def
+++ b/runtime/runtime_options.def
@@ -70,6 +70,7 @@
 RUNTIME_OPTIONS_KEY (bool,                EnableHSpaceCompactForOOM,      true)
 RUNTIME_OPTIONS_KEY (bool,                UseJitCompilation,              false)
 RUNTIME_OPTIONS_KEY (bool,                DumpNativeStackOnSigQuit,       true)
+RUNTIME_OPTIONS_KEY (bool,                MadviseRandomAccess,            false)
 RUNTIME_OPTIONS_KEY (unsigned int,        JITCompileThreshold)
 RUNTIME_OPTIONS_KEY (unsigned int,        JITWarmupThreshold)
 RUNTIME_OPTIONS_KEY (unsigned int,        JITOsrThreshold)
diff --git a/runtime/signal_catcher.cc b/runtime/signal_catcher.cc
index f0b6ee4..523584e 100644
--- a/runtime/signal_catcher.cc
+++ b/runtime/signal_catcher.cc
@@ -169,7 +169,7 @@
 
 #if defined(ART_TARGET_ANDROID)
   if (use_tombstoned_stack_trace_fd_ && !tombstoned_notify_completion(tombstone_fd)) {
-    LOG(WARNING) << "Unable to notify tombstoned of dump completion.";
+    PLOG(WARNING) << "Unable to notify tombstoned of dump completion";
   }
 #endif
 }
diff --git a/test/164-resolution-trampoline-dex-cache/expected.txt b/test/164-resolution-trampoline-dex-cache/expected.txt
new file mode 100644
index 0000000..d549cb1
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/expected.txt
@@ -0,0 +1,3 @@
+JNI_OnLoad called
+Base.foo() on MostDerived
+MostDerived.test(.) done.
diff --git a/test/164-resolution-trampoline-dex-cache/info.txt b/test/164-resolution-trampoline-dex-cache/info.txt
new file mode 100644
index 0000000..4e4d82a
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/info.txt
@@ -0,0 +1,3 @@
+Regression test for artQuickResolutionTrampoline() erroneously storing an
+ArtMethod to a DexCache for a MethodId referencing a class missing from the
+associated ClassTable. This discrepancy then led to a crash when JITting.
diff --git a/test/164-resolution-trampoline-dex-cache/profile b/test/164-resolution-trampoline-dex-cache/profile
new file mode 100644
index 0000000..d232ff2
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/profile
@@ -0,0 +1 @@
+LMostDerived;->test(Ljava/lang/Class;)V
diff --git a/test/164-resolution-trampoline-dex-cache/run b/test/164-resolution-trampoline-dex-cache/run
new file mode 100644
index 0000000..5e77cd5
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/run
@@ -0,0 +1,22 @@
+#!/bin/bash
+#
+# Copyright (C) 2017 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Use the --secondary switch to add secondary dex file to class path.
+# Make sure we compile the required method using speed-profile compiler filter.
+# Enable JIT through runtime option to avoid the compiler filter set by --jit.
+exec ${RUN} "${@}" --secondary \
+    -Xcompiler-option --compiler-filter=speed-profile --profile \
+    --runtime-option -Xusejit:true
diff --git a/test/164-resolution-trampoline-dex-cache/src-ex/MostDerived.java b/test/164-resolution-trampoline-dex-cache/src-ex/MostDerived.java
new file mode 100644
index 0000000..0c85528
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/src-ex/MostDerived.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class MostDerived extends Derived {
+    public static void test(Class main) {
+        // The defining class loader of MostDerived (MDCL) is also the initiating loader of
+        // superclass Derived but delegates the loading to its parent class loader (PCL) which
+        // defines both Derived and Base. Thus Derived.class is recorded in MDCL's ClassTable
+        // but the Base.class is not because the Base's initiating loader is PCL. This is the
+        // case when loading the MostDerived class and remains the case after resolving the
+        // "invoke-super Derived.foo(.)" called from from MostDerived.foo(.). When that
+        // invoke-super is executed from AOT-compiled code, it goes through the .bss ArtMethod*
+        // entry and on first execution goes through the resolution method. After resolving to
+        // the Base.foo(.), the artQuickResolutionTrampoline() used to erroneously fill the
+        // Base.foo(.) entry in the MostDerived's DexCache which is wrong as the referenced
+        // class Base is not in the associated, i.e. MDCL's, ClassTable.
+        new MostDerived().foo(main);
+        try {
+            // This discrepancy then used to crash when resolving the Base.foo(.) method
+            // for JIT compilation of another method.
+            main.getDeclaredMethod("ensureJitCompiled", Class.class, String.class).invoke(
+                    null, MostDerived.class, "bar");
+        } catch (Throwable t) {
+            t.printStackTrace(System.out);
+        }
+        System.out.println("MostDerived.test(.) done.");
+    }
+
+    public void foo(Class main) {
+        super.foo(main);
+    }
+
+    public void bar(Class main) {
+        Base b = this;
+        b.foo(main);
+    }
+}
diff --git a/test/164-resolution-trampoline-dex-cache/src/Base.java b/test/164-resolution-trampoline-dex-cache/src/Base.java
new file mode 100644
index 0000000..d4ef78b
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/src/Base.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Base {
+    public void foo(Class main) {
+        System.out.println("Base.foo() on " + getClass().getName());
+    }
+}
diff --git a/test/164-resolution-trampoline-dex-cache/src/Derived.java b/test/164-resolution-trampoline-dex-cache/src/Derived.java
new file mode 100644
index 0000000..acca9ce
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/src/Derived.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Derived extends Base {
+}
diff --git a/test/164-resolution-trampoline-dex-cache/src/Main.java b/test/164-resolution-trampoline-dex-cache/src/Main.java
new file mode 100644
index 0000000..b4731ae
--- /dev/null
+++ b/test/164-resolution-trampoline-dex-cache/src/Main.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+public class Main {
+    public static String TEST_NAME = "164-resolution-trampoline-dex-cache";
+
+    public static void main(String[] args) {
+        // Load the test JNI for ensureJitCompiled(). Note that classes Main loaded
+        // by other class loaders do not have the binding, so we need to pass the
+        // current Main.class around and call ensureJitCompiled() via reflection.
+        System.loadLibrary(args[0]);
+        try {
+            String dex_location = System.getenv("DEX_LOCATION");
+            ClassLoader systemLoader = ClassLoader.getSystemClassLoader().getParent();
+            ClassLoader baseLoader = getClassLoaderFor(dex_location, systemLoader, /* ex */ false);
+            ClassLoader mainLoader = getClassLoaderFor(dex_location, baseLoader, /* ex */ true);
+
+            Class<?> tc = Class.forName("MostDerived", true, mainLoader);
+            Method m = tc.getDeclaredMethod("test", Class.class);
+            m.invoke(null, Main.class);
+        } catch (Throwable t) {
+            t.printStackTrace(System.out);
+        }
+    }
+
+    public static ClassLoader getClassLoaderFor(String location, ClassLoader parent, boolean ex)
+            throws Exception {
+        try {
+            Class<?> class_loader_class = Class.forName("dalvik.system.PathClassLoader");
+            Constructor<?> ctor =
+                    class_loader_class.getConstructor(String.class, ClassLoader.class);
+            String path = location + "/" + TEST_NAME + (ex ? "-ex.jar" : ".jar");
+            return (ClassLoader)ctor.newInstance(path, parent);
+        } catch (ClassNotFoundException e) {
+            // Running on RI. Use URLClassLoader.
+            String url = "file://" + location + (ex ? "/classes-ex/" : "/classes/");
+            return new java.net.URLClassLoader(
+                    new java.net.URL[] { new java.net.URL(url) }, parent);
+        }
+    }
+
+    public static native void ensureJitCompiled(Class<?> klass, String method_name);
+}
diff --git a/test/911-get-stack-trace/src/art/PrintThread.java b/test/911-get-stack-trace/src/art/PrintThread.java
index fee5ba0..d8b3cbc 100644
--- a/test/911-get-stack-trace/src/art/PrintThread.java
+++ b/test/911-get-stack-trace/src/art/PrintThread.java
@@ -42,7 +42,7 @@
   // may not exist depending on the environment.
   public final static String IGNORE_THREAD_NAME_REGEX =
       "Binder:|RenderThread|hwuiTask|Jit thread pool worker|Instr:|JDWP|Profile Saver|main|" +
-      "queued-work-looper";
+      "queued-work-looper|InstrumentationConnectionThread";
   public final static Matcher IGNORE_THREADS =
       Pattern.compile(IGNORE_THREAD_NAME_REGEX).matcher("");
 
diff --git a/test/912-classes/expected.txt b/test/912-classes/expected.txt
index 9dcc5f9..7ad5d60 100644
--- a/test/912-classes/expected.txt
+++ b/test/912-classes/expected.txt
@@ -56,7 +56,7 @@
 boot <- 1+2 (A,B)
 [class A, class B, class java.lang.Object]
 
-[37, 0]
+[35, 0]
 
 B, false
 Load: LB; on ClassEvents
diff --git a/test/912-classes/src-art/art/Test912.java b/test/912-classes/src-art/art/Test912.java
index fbf8794..1742276 100644
--- a/test/912-classes/src-art/art/Test912.java
+++ b/test/912-classes/src-art/art/Test912.java
@@ -19,8 +19,10 @@
 import java.lang.ref.Reference;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Proxy;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.Comparator;
 
 public class Test912 {
@@ -214,8 +216,34 @@
     }
   }
 
-  private static void testClassVersion() {
-    System.out.println(Arrays.toString(getClassVersion(Main.class)));
+  /**
+   * base64 encoded class/dex file for
+   * class Transform {
+   *   public void sayHi() {
+   *    System.out.println("Goodbye");
+   *   }
+   * }
+   */
+  private static final byte[] DEX_BYTES = Base64.getDecoder().decode(
+    "ZGV4CjAzNQCLXSBQ5FiS3f16krSYZFF8xYZtFVp0GRXMAgAAcAAAAHhWNBIAAAAAAAAAACwCAAAO" +
+    "AAAAcAAAAAYAAACoAAAAAgAAAMAAAAABAAAA2AAAAAQAAADgAAAAAQAAAAABAACsAQAAIAEAAGIB" +
+    "AABqAQAAcwEAAIABAACXAQAAqwEAAL8BAADTAQAA4wEAAOYBAADqAQAA/gEAAAMCAAAMAgAAAgAA" +
+    "AAMAAAAEAAAABQAAAAYAAAAIAAAACAAAAAUAAAAAAAAACQAAAAUAAABcAQAABAABAAsAAAAAAAAA" +
+    "AAAAAAAAAAANAAAAAQABAAwAAAACAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAHAAAAAAAAAB4CAAAA" +
+    "AAAAAQABAAEAAAATAgAABAAAAHAQAwAAAA4AAwABAAIAAAAYAgAACQAAAGIAAAAbAQEAAABuIAIA" +
+    "EAAOAAAAAQAAAAMABjxpbml0PgAHR29vZGJ5ZQALTFRyYW5zZm9ybTsAFUxqYXZhL2lvL1ByaW50" +
+    "U3RyZWFtOwASTGphdmEvbGFuZy9PYmplY3Q7ABJMamF2YS9sYW5nL1N0cmluZzsAEkxqYXZhL2xh" +
+    "bmcvU3lzdGVtOwAOVHJhbnNmb3JtLmphdmEAAVYAAlZMABJlbWl0dGVyOiBqYWNrLTMuMzYAA291" +
+    "dAAHcHJpbnRsbgAFc2F5SGkAEQAHDgATAAcOhQAAAAEBAICABKACAQG4Ag0AAAAAAAAAAQAAAAAA" +
+    "AAABAAAADgAAAHAAAAACAAAABgAAAKgAAAADAAAAAgAAAMAAAAAEAAAAAQAAANgAAAAFAAAABAAA" +
+    "AOAAAAAGAAAAAQAAAAABAAABIAAAAgAAACABAAABEAAAAQAAAFwBAAACIAAADgAAAGIBAAADIAAA" +
+    "AgAAABMCAAAAIAAAAQAAAB4CAAAAEAAAAQAAACwCAAA=");
+  private static void testClassVersion() throws Exception {
+    Class<?> class_loader_class = Class.forName("dalvik.system.InMemoryDexClassLoader");
+    Constructor<?> ctor = class_loader_class.getConstructor(ByteBuffer.class, ClassLoader.class);
+    Class target = ((ClassLoader)ctor.newInstance(
+        ByteBuffer.wrap(DEX_BYTES), Test912.class.getClassLoader())).loadClass("Transform");
+    System.out.println(Arrays.toString(getClassVersion(target)));
   }
 
   private static void testClassEvents() throws Exception {
diff --git a/test/knownfailures.json b/test/knownfailures.json
index 69421de..a2502e6 100644
--- a/test/knownfailures.json
+++ b/test/knownfailures.json
@@ -105,6 +105,14 @@
         "description": ["This test sometimes runs out of memory initializing the boot classpath."]
     },
     {
+        "tests": "164-resolution-trampoline-dex-cache",
+        "variant": "interp-ac | interpreter",
+        "description": ["This test requires AOT mixed with JIT and enables the JIT by the ",
+                        "runtime option -Xusejit:true. This conflicts with -Xint passed for ",
+                        "interpreter configurations (interp-ac | interpreter). The 'jit' ",
+                        "configuration succeeds even though it does not test anything useful."]
+    },
+    {
         "tests": ["908-gc-start-finish",
                   "913-heaps"],
         "variant": "gcstress",