diff --git a/dexlayout/dexlayout_test.cc b/dexlayout/dexlayout_test.cc
index da1e1d2..2d85e8f 100644
--- a/dexlayout/dexlayout_test.cc
+++ b/dexlayout/dexlayout_test.cc
@@ -41,7 +41,7 @@
     "AAAAdQEAAAAQAAABAAAAjAEAAA==";
 
 static const char kDexFileLayoutInputProfile[] =
-    "cHJvADAwMgABAAsAAAABAPUpbf5jbGFzc2VzLmRleAEA";
+    "cHJvADAwMwABCwABAAAAAAD1KW3+Y2xhc3Nlcy5kZXgBAA==";
 
 static const char kDexFileLayoutExpectedOutputDex[] =
     "ZGV4CjAzNQD1KW3+B8NAB0f2A/ZVIBJ0aHrGIqcpVTAUAgAAcAAAAHhWNBIAAAAAAAAAAIwBAAAH"
diff --git a/profman/profman.cc b/profman/profman.cc
index 8f35a76..a42e4f1 100644
--- a/profman/profman.cc
+++ b/profman/profman.cc
@@ -593,7 +593,7 @@
     }
     // Generate the profile data structure.
     ProfileCompilationInfo info;
-    std::vector<MethodReference> methods;  // No methods for now.
+    std::vector<ProfileMethodInfo> methods;  // No methods for now.
     info.AddMethodsAndClasses(methods, resolved_class_set);
     // Write the profile file.
     CHECK(info.Save(fd));
diff --git a/runtime/jit/jit_code_cache.cc b/runtime/jit/jit_code_cache.cc
index 60ab275..c226a38 100644
--- a/runtime/jit/jit_code_cache.cc
+++ b/runtime/jit/jit_code_cache.cc
@@ -1245,15 +1245,40 @@
 }
 
 void JitCodeCache::GetProfiledMethods(const std::set<std::string>& dex_base_locations,
-                                      std::vector<MethodReference>& methods) {
+                                      std::vector<ProfileMethodInfo>& methods) {
   ScopedTrace trace(__FUNCTION__);
   MutexLock mu(Thread::Current(), lock_);
   for (const ProfilingInfo* info : profiling_infos_) {
     ArtMethod* method = info->GetMethod();
     const DexFile* dex_file = method->GetDexFile();
-    if (ContainsElement(dex_base_locations, dex_file->GetBaseLocation())) {
-      methods.emplace_back(dex_file,  method->GetDexMethodIndex());
+    if (!ContainsElement(dex_base_locations, dex_file->GetBaseLocation())) {
+      // Skip dex files which are not profiled.
+      continue;
     }
+    std::vector<ProfileMethodInfo::ProfileInlineCache> inline_caches;
+    for (size_t i = 0; i < info->number_of_inline_caches_; ++i) {
+      std::vector<ProfileMethodInfo::ProfileClassReference> profile_classes;
+      const InlineCache& cache = info->cache_[i];
+      for (size_t k = 0; k < InlineCache::kIndividualCacheSize; k++) {
+        mirror::Class* cls = cache.classes_[k].Read();
+        if (cls == nullptr) {
+          break;
+        }
+        const DexFile& class_dex_file = cls->GetDexFile();
+        dex::TypeIndex type_index = cls->GetDexTypeIndex();
+        if (ContainsElement(dex_base_locations, class_dex_file.GetBaseLocation())) {
+          // Only consider classes from the same apk (including multidex).
+          profile_classes.emplace_back(/*ProfileMethodInfo::ProfileClassReference*/
+              &class_dex_file, type_index);
+        }
+      }
+      if (!profile_classes.empty()) {
+        inline_caches.emplace_back(/*ProfileMethodInfo::ProfileInlineCache*/
+            cache.dex_pc_, profile_classes);
+      }
+    }
+    methods.emplace_back(/*ProfileMethodInfo*/
+        dex_file, method->GetDexMethodIndex(), inline_caches);
   }
 }
 
diff --git a/runtime/jit/jit_code_cache.h b/runtime/jit/jit_code_cache.h
index b5e3176..33a792f 100644
--- a/runtime/jit/jit_code_cache.h
+++ b/runtime/jit/jit_code_cache.h
@@ -30,6 +30,7 @@
 #include "method_reference.h"
 #include "oat_file.h"
 #include "object_callbacks.h"
+#include "profile_compilation_info.h"
 #include "safe_map.h"
 #include "thread_pool.h"
 
@@ -192,7 +193,7 @@
 
   // Adds to `methods` all profiled methods which are part of any of the given dex locations.
   void GetProfiledMethods(const std::set<std::string>& dex_base_locations,
-                          std::vector<MethodReference>& methods)
+                          std::vector<ProfileMethodInfo>& methods)
       REQUIRES(!lock_)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
diff --git a/runtime/jit/profile_compilation_info.cc b/runtime/jit/profile_compilation_info.cc
index 54fc038..5638ce1 100644
--- a/runtime/jit/profile_compilation_info.cc
+++ b/runtime/jit/profile_compilation_info.cc
@@ -37,7 +37,7 @@
 namespace art {
 
 const uint8_t ProfileCompilationInfo::kProfileMagic[] = { 'p', 'r', 'o', '\0' };
-const uint8_t ProfileCompilationInfo::kProfileVersion[] = { '0', '0', '2', '\0' };
+const uint8_t ProfileCompilationInfo::kProfileVersion[] = { '0', '0', '3', '\0' };  // inline caches
 
 static constexpr uint16_t kMaxDexFileKeyLength = PATH_MAX;
 
@@ -46,6 +46,25 @@
 // using the same test profile.
 static constexpr bool kDebugIgnoreChecksum = false;
 
+static constexpr uint8_t kMegamorphicEncoding = 7;
+
+static_assert(sizeof(InlineCache::kIndividualCacheSize) == sizeof(uint8_t),
+              "InlineCache::kIndividualCacheSize does not have the expect type size");
+static_assert(InlineCache::kIndividualCacheSize < kMegamorphicEncoding,
+              "InlineCache::kIndividualCacheSize is larger than expected");
+
+void ProfileCompilationInfo::DexPcData::AddClass(uint16_t dex_profile_idx,
+                                                 const dex::TypeIndex& type_idx) {
+  if (is_megamorphic) {
+    return;
+  }
+  classes.emplace(dex_profile_idx, type_idx);
+  if (classes.size() >= InlineCache::kIndividualCacheSize) {
+    is_megamorphic = true;
+    classes.clear();
+  }
+}
+
 // Transform the actual dex location into relative paths.
 // Note: this is OK because we don't store profiles of different apps into the same file.
 // Apps with split apks don't cause trouble because each split has a different name and will not
@@ -62,12 +81,10 @@
 }
 
 bool ProfileCompilationInfo::AddMethodsAndClasses(
-    const std::vector<MethodReference>& methods,
+    const std::vector<ProfileMethodInfo>& methods,
     const std::set<DexCacheResolvedClasses>& resolved_classes) {
-  for (const MethodReference& method : methods) {
-    if (!AddMethodIndex(GetProfileDexFileKey(method.dex_file->GetLocation()),
-                        method.dex_file->GetLocationChecksum(),
-                        method.dex_method_index)) {
+  for (const ProfileMethodInfo& method : methods) {
+    if (!AddMethod(method)) {
       return false;
     }
   }
@@ -170,29 +187,40 @@
 }
 
 static constexpr size_t kLineHeaderSize =
-    3 * sizeof(uint16_t) +  // method_set.size + class_set.size + dex_location.size
-    sizeof(uint32_t);       // checksum
+    2 * sizeof(uint16_t) +  // class_set.size + dex_location.size
+    2 * sizeof(uint32_t);   // method_map.size + checksum
 
 /**
  * Serialization format:
- *    magic,version,number_of_lines
- *    dex_location1,number_of_methods1,number_of_classes1,dex_location_checksum1, \
- *        method_id11,method_id12...,class_id1,class_id2...
- *    dex_location2,number_of_methods2,number_of_classes2,dex_location_checksum2, \
- *        method_id21,method_id22...,,class_id1,class_id2...
+ *    magic,version,number_of_dex_files
+ *    dex_location1,number_of_classes1,methods_region_size,dex_location_checksum1, \
+ *        method_encoding_11,method_encoding_12...,class_id1,class_id2...
+ *    dex_location2,number_of_classes2,methods_region_size,dex_location_checksum2, \
+ *        method_encoding_21,method_encoding_22...,,class_id1,class_id2...
  *    .....
+ * The method_encoding is:
+ *    method_id,number_of_inline_caches,inline_cache1,inline_cache2...
+ * The inline_cache is:
+ *    dex_pc,[M|dex_map_size], dex_profile_index,class_id1,class_id2...,dex_profile_index2,...
+ *    dex_map_size is the number of dex_indeces that follows.
+ *       Classes are grouped per their dex files and the line
+ *       `dex_profile_index,class_id1,class_id2...,dex_profile_index2,...` encodes the
+ *       mapping from `dex_profile_index` to the set of classes `class_id1,class_id2...`
+ *    M stands for megamorphic and it's encoded as the byte kMegamorphicEncoding.
+ *    When present, there will be no class ids following.
  **/
 bool ProfileCompilationInfo::Save(int fd) {
   ScopedTrace trace(__PRETTY_FUNCTION__);
   DCHECK_GE(fd, 0);
 
-  // Cache at most 5KB before writing.
-  static constexpr size_t kMaxSizeToKeepBeforeWriting = 5 * KB;
+  // Cache at most 50KB before writing.
+  static constexpr size_t kMaxSizeToKeepBeforeWriting = 50 * KB;
   // Use a vector wrapper to avoid keeping track of offsets when we add elements.
   std::vector<uint8_t> buffer;
   WriteBuffer(fd, kProfileMagic, sizeof(kProfileMagic));
   WriteBuffer(fd, kProfileVersion, sizeof(kProfileVersion));
-  AddUintToBuffer(&buffer, static_cast<uint16_t>(info_.size()));
+  DCHECK_LE(info_.size(), std::numeric_limits<uint8_t>::max());
+  AddUintToBuffer(&buffer, static_cast<uint8_t>(info_.size()));
 
   for (const auto& it : info_) {
     if (buffer.size() > kMaxSizeToKeepBeforeWriting) {
@@ -203,9 +231,9 @@
     }
     const std::string& dex_location = it.first;
     const DexFileData& dex_data = it.second;
-    if (dex_data.method_set.empty() && dex_data.class_set.empty()) {
-      continue;
-    }
+
+    // Note that we allow dex files without any methods or classes, so that
+    // inline caches can refer valid dex files.
 
     if (dex_location.size() >= kMaxDexFileKeyLength) {
       LOG(WARNING) << "DexFileKey exceeds allocated limit";
@@ -214,42 +242,128 @@
 
     // Make sure that the buffer has enough capacity to avoid repeated resizings
     // while we add data.
+    uint32_t methods_region_size = GetMethodsRegionSize(dex_data);
     size_t required_capacity = buffer.size() +
         kLineHeaderSize +
         dex_location.size() +
-        sizeof(uint16_t) * (dex_data.class_set.size() + dex_data.method_set.size());
+        sizeof(uint16_t) * dex_data.class_set.size() +
+        methods_region_size;
 
     buffer.reserve(required_capacity);
-
     DCHECK_LE(dex_location.size(), std::numeric_limits<uint16_t>::max());
-    DCHECK_LE(dex_data.method_set.size(), std::numeric_limits<uint16_t>::max());
     DCHECK_LE(dex_data.class_set.size(), std::numeric_limits<uint16_t>::max());
     AddUintToBuffer(&buffer, static_cast<uint16_t>(dex_location.size()));
-    AddUintToBuffer(&buffer, static_cast<uint16_t>(dex_data.method_set.size()));
     AddUintToBuffer(&buffer, static_cast<uint16_t>(dex_data.class_set.size()));
+    AddUintToBuffer(&buffer, methods_region_size);  // uint32_t
     AddUintToBuffer(&buffer, dex_data.checksum);  // uint32_t
 
     AddStringToBuffer(&buffer, dex_location);
 
-    for (auto method_it : dex_data.method_set) {
-      AddUintToBuffer(&buffer, method_it);
+    for (const auto& method_it : dex_data.method_map) {
+      AddUintToBuffer(&buffer, method_it.first);
+      AddInlineCacheToBuffer(&buffer, method_it.second);
     }
-    for (auto class_id : dex_data.class_set) {
+    for (const auto& class_id : dex_data.class_set) {
       AddUintToBuffer(&buffer, class_id.index_);
     }
-    DCHECK_EQ(required_capacity, buffer.size())
+
+    DCHECK_LE(required_capacity, buffer.size())
         << "Failed to add the expected number of bytes in the buffer";
   }
 
   return WriteBuffer(fd, buffer.data(), buffer.size());
 }
 
+void ProfileCompilationInfo::AddInlineCacheToBuffer(std::vector<uint8_t>* buffer,
+                                                    const InlineCacheMap& inline_cache_map) {
+  // Add inline cache map size.
+  AddUintToBuffer(buffer, static_cast<uint16_t>(inline_cache_map.size()));
+  if (inline_cache_map.size() == 0) {
+    return;
+  }
+  for (const auto& inline_cache_it : inline_cache_map) {
+    uint16_t dex_pc = inline_cache_it.first;
+    const DexPcData dex_pc_data = inline_cache_it.second;
+    const ClassSet& classes = dex_pc_data.classes;
+
+    // Add the dex pc.
+    AddUintToBuffer(buffer, dex_pc);
+
+    if (dex_pc_data.is_megamorphic) {
+      // Add the megamorphic encoding if needed and continue.
+      // If megamorphic, we don't add the rest of the classes.
+      AddUintToBuffer(buffer, kMegamorphicEncoding);
+      continue;
+    }
+
+    DCHECK_LT(classes.size(), InlineCache::kIndividualCacheSize);
+    DCHECK_NE(classes.size(), 0u) << "InlineCache contains a dex_pc with 0 classes";
+
+    SafeMap<uint8_t, std::vector<dex::TypeIndex>> dex_to_classes_map;
+    // Group the classes by dex. We expect that most of the classes will come from
+    // the same dex, so this will be more efficient than encoding the dex index
+    // for each class reference.
+    GroupClassesByDex(classes, &dex_to_classes_map);
+    // Add the dex map size.
+    AddUintToBuffer(buffer, static_cast<uint8_t>(dex_to_classes_map.size()));
+    for (const auto& dex_it : dex_to_classes_map) {
+      uint8_t dex_profile_index = dex_it.first;
+      const std::vector<dex::TypeIndex>& dex_classes = dex_it.second;
+      // Add the dex profile index.
+      AddUintToBuffer(buffer, dex_profile_index);
+      // Add the the number of classes for each dex profile index.
+      AddUintToBuffer(buffer, static_cast<uint8_t>(dex_classes.size()));
+      for (size_t i = 0; i < dex_classes.size(); i++) {
+        // Add the type index of the classes.
+        AddUintToBuffer(buffer, dex_classes[i].index_);
+      }
+    }
+  }
+}
+
+uint32_t ProfileCompilationInfo::GetMethodsRegionSize(const DexFileData& dex_data) {
+  // ((uint16_t)method index + (uint16_t)inline cache size) * number of methods
+  uint32_t size = 2 * sizeof(uint16_t) * dex_data.method_map.size();
+  for (const auto& method_it : dex_data.method_map) {
+    const InlineCacheMap& inline_cache = method_it.second;
+    size += sizeof(uint16_t) * inline_cache.size();  // dex_pc
+    for (const auto& inline_cache_it : inline_cache) {
+      const ClassSet& classes = inline_cache_it.second.classes;
+      SafeMap<uint8_t, std::vector<dex::TypeIndex>> dex_to_classes_map;
+      GroupClassesByDex(classes, &dex_to_classes_map);
+      size += sizeof(uint8_t);  // dex_to_classes_map size
+      for (const auto& dex_it : dex_to_classes_map) {
+        size += sizeof(uint8_t);  // dex profile index
+        size += sizeof(uint8_t);  // number of classes
+        const std::vector<dex::TypeIndex>& dex_classes = dex_it.second;
+        size += sizeof(uint16_t) * dex_classes.size();  // the actual classes
+      }
+    }
+  }
+  return size;
+}
+
+void ProfileCompilationInfo::GroupClassesByDex(
+    const ClassSet& classes,
+    /*out*/SafeMap<uint8_t, std::vector<dex::TypeIndex>>* dex_to_classes_map) {
+  for (const auto& classes_it : classes) {
+    auto dex_it = dex_to_classes_map->FindOrAdd(classes_it.dex_profile_index);
+    dex_it->second.push_back(classes_it.type_index);
+  }
+}
+
 ProfileCompilationInfo::DexFileData* ProfileCompilationInfo::GetOrAddDexFileData(
     const std::string& dex_location,
     uint32_t checksum) {
-  auto info_it = info_.find(dex_location);
-  if (info_it == info_.end()) {
-    info_it = info_.Put(dex_location, DexFileData(checksum));
+  auto info_it = info_.FindOrAdd(dex_location, DexFileData(checksum, info_.size()));
+  if (info_.size() > std::numeric_limits<uint8_t>::max()) {
+    // Allow only 255 dex files to be profiled. This allows us to save bytes
+    // when encoding. The number is well above what we expect for normal applications.
+    if (kIsDebugBuild) {
+      LOG(WARNING) << "Exceeded the maximum number of dex files (255). Something went wrong";
+    }
+    info_.erase(dex_location);
+    return nullptr;
   }
   if (info_it->second.checksum != checksum) {
     LOG(WARNING) << "Checksum mismatch for dex " << dex_location;
@@ -270,13 +384,65 @@
 }
 
 bool ProfileCompilationInfo::AddMethodIndex(const std::string& dex_location,
-                                            uint32_t checksum,
-                                            uint16_t method_idx) {
-  DexFileData* const data = GetOrAddDexFileData(dex_location, checksum);
-  if (data == nullptr) {
+                                            uint32_t dex_checksum,
+                                            uint16_t method_index) {
+  return AddMethod(dex_location, dex_checksum, method_index, OfflineProfileMethodInfo());
+}
+
+bool ProfileCompilationInfo::AddMethod(const std::string& dex_location,
+                                       uint32_t dex_checksum,
+                                       uint16_t method_index,
+                                       const OfflineProfileMethodInfo& pmi) {
+  DexFileData* const data = GetOrAddDexFileData(
+      GetProfileDexFileKey(dex_location),
+      dex_checksum);
+  if (data == nullptr) {  // checksum mismatch
     return false;
   }
-  data->method_set.insert(method_idx);
+  auto inline_cache_it = data->method_map.FindOrAdd(method_index);
+  for (const auto& pmi_inline_cache_it : pmi.inline_caches) {
+    uint16_t pmi_ic_dex_pc = pmi_inline_cache_it.first;
+    const DexPcData& pmi_ic_dex_pc_data = pmi_inline_cache_it.second;
+    auto dex_pc_data_it = inline_cache_it->second.FindOrAdd(pmi_ic_dex_pc);
+    if (pmi_ic_dex_pc_data.is_megamorphic) {
+      dex_pc_data_it->second.SetMegamorphic();
+      continue;
+    }
+    for (const ClassReference& class_ref : pmi_ic_dex_pc_data.classes) {
+      const DexReference& dex_ref = pmi.dex_references[class_ref.dex_profile_index];
+      DexFileData* class_dex_data = GetOrAddDexFileData(
+          GetProfileDexFileKey(dex_ref.dex_location),
+          dex_ref.dex_checksum);
+      if (class_dex_data == nullptr) {  // checksum mismatch
+        return false;
+      }
+      dex_pc_data_it->second.AddClass(class_dex_data->profile_index, class_ref.type_index);
+    }
+  }
+  return true;
+}
+
+bool ProfileCompilationInfo::AddMethod(const ProfileMethodInfo& pmi) {
+  DexFileData* const data = GetOrAddDexFileData(
+      GetProfileDexFileKey(pmi.dex_file->GetLocation()),
+      pmi.dex_file->GetLocationChecksum());
+  if (data == nullptr) {  // checksum mismatch
+    return false;
+  }
+  auto inline_cache_it = data->method_map.FindOrAdd(pmi.dex_method_index);
+
+  for (const ProfileMethodInfo::ProfileInlineCache& cache : pmi.inline_caches) {
+    for (const ProfileMethodInfo::ProfileClassReference& class_ref : cache.classes) {
+      DexFileData* class_dex_data = GetOrAddDexFileData(
+          GetProfileDexFileKey(class_ref.dex_file->GetLocation()),
+          class_ref.dex_file->GetLocationChecksum());
+      if (class_dex_data == nullptr) {  // checksum mismatch
+        return false;
+      }
+      auto dex_pc_data_it = inline_cache_it->second.FindOrAdd(cache.dex_pc);
+      dex_pc_data_it->second.AddClass(class_dex_data->profile_index, class_ref.type_index);
+    }
+  }
   return true;
 }
 
@@ -291,21 +457,79 @@
   return true;
 }
 
-bool ProfileCompilationInfo::ProcessLine(SafeBuffer& line_buffer,
-                                         uint16_t method_set_size,
-                                         uint16_t class_set_size,
-                                         uint32_t checksum,
-                                         const std::string& dex_location) {
-  for (uint16_t i = 0; i < method_set_size; i++) {
-    uint16_t method_idx = line_buffer.ReadUintAndAdvance<uint16_t>();
-    if (!AddMethodIndex(dex_location, checksum, method_idx)) {
+#define READ_UINT(type, buffer, dest, error)          \
+  do {                                                \
+    if (!buffer.ReadUintAndAdvance<type>(&dest)) {    \
+      *error = "Could not read "#dest;                \
+      return false;                                   \
+    }                                                 \
+  }                                                   \
+  while (false)
+
+bool ProfileCompilationInfo::ReadInlineCache(SafeBuffer& buffer,
+                                             uint8_t number_of_dex_files,
+                                             /*out*/ InlineCacheMap* inline_cache,
+                                             /*out*/ std::string* error) {
+  uint16_t inline_cache_size;
+  READ_UINT(uint16_t, buffer, inline_cache_size, error);
+  for (; inline_cache_size > 0; inline_cache_size--) {
+    uint16_t dex_pc;
+    uint8_t dex_to_classes_map_size;
+    READ_UINT(uint16_t, buffer, dex_pc, error);
+    READ_UINT(uint8_t, buffer, dex_to_classes_map_size, error);
+    auto dex_pc_data_it = inline_cache->FindOrAdd(dex_pc);
+    if (dex_to_classes_map_size == kMegamorphicEncoding) {
+      dex_pc_data_it->second.SetMegamorphic();
+      continue;
+    }
+    for (; dex_to_classes_map_size > 0; dex_to_classes_map_size--) {
+      uint8_t dex_profile_index;
+      uint8_t dex_classes_size;
+      READ_UINT(uint8_t, buffer, dex_profile_index, error);
+      READ_UINT(uint8_t, buffer, dex_classes_size, error);
+      if (dex_profile_index >= number_of_dex_files) {
+        *error = "dex_profile_index out of bounds ";
+        *error += std::to_string(dex_profile_index) + " " + std::to_string(number_of_dex_files);
+        return false;
+      }
+      for (; dex_classes_size > 0; dex_classes_size--) {
+        uint16_t type_index;
+        READ_UINT(uint16_t, buffer, type_index, error);
+        dex_pc_data_it->second.AddClass(dex_profile_index, dex::TypeIndex(type_index));
+      }
+    }
+  }
+  return true;
+}
+
+bool ProfileCompilationInfo::ReadMethods(SafeBuffer& buffer,
+                                         uint8_t number_of_dex_files,
+                                         const ProfileLineHeader& line_header,
+                                         /*out*/std::string* error) {
+  while (buffer.HasMoreData()) {
+    DexFileData* const data = GetOrAddDexFileData(line_header.dex_location, line_header.checksum);
+    uint16_t method_index;
+    READ_UINT(uint16_t, buffer, method_index, error);
+
+    auto it = data->method_map.FindOrAdd(method_index);
+    if (!ReadInlineCache(buffer, number_of_dex_files, &(it->second), error)) {
       return false;
     }
   }
 
-  for (uint16_t i = 0; i < class_set_size; i++) {
-    uint16_t type_idx = line_buffer.ReadUintAndAdvance<uint16_t>();
-    if (!AddClassIndex(dex_location, checksum, dex::TypeIndex(type_idx))) {
+  return true;
+}
+
+bool ProfileCompilationInfo::ReadClasses(SafeBuffer& buffer,
+                                         uint16_t classes_to_read,
+                                         const ProfileLineHeader& line_header,
+                                         /*out*/std::string* error) {
+  for (uint16_t i = 0; i < classes_to_read; i++) {
+    uint16_t type_index;
+    READ_UINT(uint16_t, buffer, type_index, error);
+    if (!AddClassIndex(line_header.dex_location,
+                       line_header.checksum,
+                       dex::TypeIndex(type_index))) {
       return false;
     }
   }
@@ -324,15 +548,17 @@
 
 // Reads an uint value previously written with AddUintToBuffer.
 template <typename T>
-T ProfileCompilationInfo::SafeBuffer::ReadUintAndAdvance() {
+bool ProfileCompilationInfo::SafeBuffer::ReadUintAndAdvance(/*out*/T* value) {
   static_assert(std::is_unsigned<T>::value, "Type is not unsigned");
-  CHECK_LE(ptr_current_ + sizeof(T), ptr_end_);
-  T value = 0;
+  if (ptr_current_ + sizeof(T) > ptr_end_) {
+    return false;
+  }
+  *value = 0;
   for (size_t i = 0; i < sizeof(T); i++) {
-    value += ptr_current_[i] << (i * kBitsPerByte);
+    *value += ptr_current_[i] << (i * kBitsPerByte);
   }
   ptr_current_ += sizeof(T);
-  return value;
+  return true;
 }
 
 bool ProfileCompilationInfo::SafeBuffer::CompareAndAdvance(const uint8_t* data, size_t data_size) {
@@ -346,6 +572,10 @@
   return false;
 }
 
+bool ProfileCompilationInfo::SafeBuffer::HasMoreData() {
+  return ptr_current_ < ptr_end_;
+}
+
 ProfileCompilationInfo::ProfileLoadSatus ProfileCompilationInfo::SafeBuffer::FillFromFd(
       int fd,
       const std::string& source,
@@ -369,13 +599,13 @@
 
 ProfileCompilationInfo::ProfileLoadSatus ProfileCompilationInfo::ReadProfileHeader(
       int fd,
-      /*out*/uint16_t* number_of_lines,
+      /*out*/uint8_t* number_of_dex_files,
       /*out*/std::string* error) {
   // Read magic and version
   const size_t kMagicVersionSize =
     sizeof(kProfileMagic) +
     sizeof(kProfileVersion) +
-    sizeof(uint16_t);  // number of lines
+    sizeof(uint8_t);  // number of dex files
 
   SafeBuffer safe_buffer(kMagicVersionSize);
 
@@ -392,24 +622,38 @@
     *error = "Profile version mismatch";
     return kProfileLoadVersionMismatch;
   }
-  *number_of_lines = safe_buffer.ReadUintAndAdvance<uint16_t>();
+  if (!safe_buffer.ReadUintAndAdvance<uint8_t>(number_of_dex_files)) {
+    *error = "Cannot read the number of dex files";
+    return kProfileLoadBadData;
+  }
   return kProfileLoadSuccess;
 }
 
+bool ProfileCompilationInfo::ReadProfileLineHeaderElements(SafeBuffer& buffer,
+                                                           /*out*/uint16_t* dex_location_size,
+                                                           /*out*/ProfileLineHeader* line_header,
+                                                           /*out*/std::string* error) {
+  READ_UINT(uint16_t, buffer, *dex_location_size, error);
+  READ_UINT(uint16_t, buffer, line_header->class_set_size, error);
+  READ_UINT(uint32_t, buffer, line_header->method_region_size_bytes, error);
+  READ_UINT(uint32_t, buffer, line_header->checksum, error);
+  return true;
+}
+
 ProfileCompilationInfo::ProfileLoadSatus ProfileCompilationInfo::ReadProfileLineHeader(
       int fd,
       /*out*/ProfileLineHeader* line_header,
       /*out*/std::string* error) {
   SafeBuffer header_buffer(kLineHeaderSize);
-  ProfileLoadSatus status = header_buffer.FillFromFd(fd, "ReadProfileHeader", error);
+  ProfileLoadSatus status = header_buffer.FillFromFd(fd, "ReadProfileLineHeader", error);
   if (status != kProfileLoadSuccess) {
     return status;
   }
 
-  uint16_t dex_location_size = header_buffer.ReadUintAndAdvance<uint16_t>();
-  line_header->method_set_size = header_buffer.ReadUintAndAdvance<uint16_t>();
-  line_header->class_set_size = header_buffer.ReadUintAndAdvance<uint16_t>();
-  line_header->checksum = header_buffer.ReadUintAndAdvance<uint32_t>();
+  uint16_t dex_location_size;
+  if (!ReadProfileLineHeaderElements(header_buffer, &dex_location_size, line_header, error)) {
+    return kProfileLoadBadData;
+  }
 
   if (dex_location_size == 0 || dex_location_size > kMaxDexFileKeyLength) {
     *error = "DexFileKey has an invalid size: " +
@@ -429,37 +673,38 @@
 
 ProfileCompilationInfo::ProfileLoadSatus ProfileCompilationInfo::ReadProfileLine(
       int fd,
+      uint8_t number_of_dex_files,
       const ProfileLineHeader& line_header,
       /*out*/std::string* error) {
-  // Make sure that we don't try to read everything in memory (in case the profile if full).
-  // Split readings in chunks of at most 10kb.
-  static constexpr uint16_t kMaxNumberOfEntriesToRead = 5120;
-  uint16_t methods_left_to_read = line_header.method_set_size;
-  uint16_t classes_left_to_read = line_header.class_set_size;
+  if (GetOrAddDexFileData(line_header.dex_location, line_header.checksum) == nullptr) {
+    *error = "Error when reading profile file line header: checksum mismatch for "
+        + line_header.dex_location;
+    return kProfileLoadBadData;
+  }
 
-  while ((methods_left_to_read > 0) || (classes_left_to_read > 0)) {
-    uint16_t methods_to_read = std::min(kMaxNumberOfEntriesToRead, methods_left_to_read);
-    uint16_t max_classes_to_read = kMaxNumberOfEntriesToRead - methods_to_read;
-    uint16_t classes_to_read = std::min(max_classes_to_read, classes_left_to_read);
-
-    size_t line_size = sizeof(uint16_t) * (methods_to_read + classes_to_read);
-    SafeBuffer line_buffer(line_size);
-
-    ProfileLoadSatus status = line_buffer.FillFromFd(fd, "ReadProfileLine", error);
+  {
+    SafeBuffer buffer(line_header.method_region_size_bytes);
+    ProfileLoadSatus status = buffer.FillFromFd(fd, "ReadProfileLineMethods", error);
     if (status != kProfileLoadSuccess) {
       return status;
     }
-    if (!ProcessLine(line_buffer,
-                     methods_to_read,
-                     classes_to_read,
-                     line_header.checksum,
-                     line_header.dex_location)) {
-      *error = "Error when reading profile file line";
+
+    if (!ReadMethods(buffer, number_of_dex_files, line_header, error)) {
       return kProfileLoadBadData;
     }
-    methods_left_to_read -= methods_to_read;
-    classes_left_to_read -= classes_to_read;
   }
+
+  {
+    SafeBuffer buffer(sizeof(uint16_t) * line_header.class_set_size);
+    ProfileLoadSatus status = buffer.FillFromFd(fd, "ReadProfileLineClasses", error);
+    if (status != kProfileLoadSuccess) {
+      return status;
+    }
+    if (!ReadClasses(buffer, line_header.class_set_size, line_header, error)) {
+      return kProfileLoadBadData;
+    }
+  }
+
   return kProfileLoadSuccess;
 }
 
@@ -470,7 +715,7 @@
   if (status == kProfileLoadSuccess) {
     return true;
   } else {
-    PLOG(WARNING) << "Error when reading profile " << error;
+    LOG(WARNING) << "Error when reading profile: " << error;
     return false;
   }
 }
@@ -490,15 +735,16 @@
   if (stat_buffer.st_size == 0) {
     return kProfileLoadSuccess;
   }
-  // Read profile header: magic + version + number_of_lines.
-  uint16_t number_of_lines;
-  ProfileLoadSatus status = ReadProfileHeader(fd, &number_of_lines, error);
+  // Read profile header: magic + version + number_of_dex_files.
+  uint8_t number_of_dex_files;
+  ProfileLoadSatus status = ReadProfileHeader(fd, &number_of_dex_files, error);
   if (status != kProfileLoadSuccess) {
     return status;
   }
 
-  while (number_of_lines > 0) {
+  for (uint8_t k = 0; k < number_of_dex_files; k++) {
     ProfileLineHeader line_header;
+
     // First, read the line header to get the amount of data we need to read.
     status = ReadProfileLineHeader(fd, &line_header, error);
     if (status != kProfileLoadSuccess) {
@@ -506,11 +752,10 @@
     }
 
     // Now read the actual profile line.
-    status = ReadProfileLine(fd, line_header, error);
+    status = ReadProfileLine(fd, number_of_dex_files, line_header, error);
     if (status != kProfileLoadSuccess) {
       return status;
     }
-    number_of_lines--;
   }
 
   // Check that we read everything and that profiles don't contain junk data.
@@ -538,37 +783,112 @@
     }
   }
   // All checksums match. Import the data.
+
+  // The other profile might have a different indexing of dex files.
+  // That is because each dex files gets a 'dex_profile_index' on a first come first served basis.
+  // That means that the order in with the methods are added to the profile matters for the
+  // actual indices.
+  // The reason we cannot rely on the actual multidex index is that a single profile may store
+  // data from multiple splits. This means that a profile may contain a classes2.dex from split-A
+  // and one from split-B.
+
+  // First, build a mapping from other_dex_profile_index to this_dex_profile_index.
+  // This will make sure that the ClassReferences  will point to the correct dex file.
+  SafeMap<uint8_t, uint8_t> dex_profile_index_remap;
+  for (const auto& other_it : other.info_) {
+    const std::string& other_dex_location = other_it.first;
+    const DexFileData& other_dex_data = other_it.second;
+    auto info_it = info_.FindOrAdd(other_dex_location, DexFileData(other_dex_data.checksum, 0));
+    const DexFileData& dex_data = info_it->second;
+    dex_profile_index_remap.Put(other_dex_data.profile_index, dex_data.profile_index);
+  }
+
+  // Merge the actual profile data.
   for (const auto& other_it : other.info_) {
     const std::string& other_dex_location = other_it.first;
     const DexFileData& other_dex_data = other_it.second;
     auto info_it = info_.find(other_dex_location);
-    if (info_it == info_.end()) {
-      info_it = info_.Put(other_dex_location, DexFileData(other_dex_data.checksum));
-    }
-    info_it->second.method_set.insert(other_dex_data.method_set.begin(),
-                                      other_dex_data.method_set.end());
+    DCHECK(info_it != info_.end());
+
+    // Merge the classes.
     info_it->second.class_set.insert(other_dex_data.class_set.begin(),
                                      other_dex_data.class_set.end());
+
+    // Merge the methods and the inline caches.
+    for (const auto& other_method_it : other_dex_data.method_map) {
+      uint16_t other_method_index = other_method_it.first;
+      auto method_it = info_it->second.method_map.FindOrAdd(other_method_index);
+      const auto& other_inline_cache = other_method_it.second;
+      for (const auto& other_ic_it : other_inline_cache) {
+        uint16_t other_dex_pc = other_ic_it.first;
+        const ClassSet& other_class_set = other_ic_it.second.classes;
+        auto class_set = method_it->second.FindOrAdd(other_dex_pc);
+        for (const auto& class_it : other_class_set) {
+          class_set->second.AddClass(dex_profile_index_remap.Get(
+              class_it.dex_profile_index), class_it.type_index);
+        }
+      }
+    }
   }
   return true;
 }
 
+static bool ChecksumMatch(uint32_t dex_file_checksum, uint32_t checksum) {
+  return kDebugIgnoreChecksum || dex_file_checksum == checksum;
+}
+
 static bool ChecksumMatch(const DexFile& dex_file, uint32_t checksum) {
-  return kDebugIgnoreChecksum || dex_file.GetLocationChecksum() == checksum;
+  return ChecksumMatch(dex_file.GetLocationChecksum(), checksum);
 }
 
 bool ProfileCompilationInfo::ContainsMethod(const MethodReference& method_ref) const {
-  auto info_it = info_.find(GetProfileDexFileKey(method_ref.dex_file->GetLocation()));
-  if (info_it != info_.end()) {
-    if (!ChecksumMatch(*method_ref.dex_file, info_it->second.checksum)) {
-      return false;
-    }
-    const std::set<uint16_t>& methods = info_it->second.method_set;
-    return methods.find(method_ref.dex_method_index) != methods.end();
-  }
-  return false;
+  return FindMethod(method_ref.dex_file->GetLocation(),
+                    method_ref.dex_file->GetLocationChecksum(),
+                    method_ref.dex_method_index) != nullptr;
 }
 
+const ProfileCompilationInfo::InlineCacheMap*
+ProfileCompilationInfo::FindMethod(const std::string& dex_location,
+                                   uint32_t dex_checksum,
+                                   uint16_t dex_method_index) const {
+  auto info_it = info_.find(GetProfileDexFileKey(dex_location));
+  if (info_it != info_.end()) {
+    if (!ChecksumMatch(dex_checksum, info_it->second.checksum)) {
+      return nullptr;
+    }
+    const MethodMap& methods = info_it->second.method_map;
+    const auto method_it = methods.find(dex_method_index);
+    return method_it == methods.end() ? nullptr : &(method_it->second);
+  }
+  return nullptr;
+}
+
+void ProfileCompilationInfo::DexFileToProfileIndex(
+    /*out*/std::vector<DexReference>* dex_references) const {
+  dex_references->resize(info_.size());
+  for (const auto& info_it : info_) {
+    DexReference& dex_ref = (*dex_references)[info_it.second.profile_index];
+    dex_ref.dex_location = info_it.first;
+    dex_ref.dex_checksum = info_it.second.checksum;
+  }
+}
+
+bool ProfileCompilationInfo::GetMethod(const std::string& dex_location,
+                                       uint32_t dex_checksum,
+                                       uint16_t dex_method_index,
+                                       /*out*/OfflineProfileMethodInfo* pmi) const {
+  const InlineCacheMap* inline_caches = FindMethod(dex_location, dex_checksum, dex_method_index);
+  if (inline_caches == nullptr) {
+    return false;
+  }
+
+  DexFileToProfileIndex(&pmi->dex_references);
+  // TODO(calin): maybe expose a direct pointer to avoid copying
+  pmi->inline_caches = *inline_caches;
+  return true;
+}
+
+
 bool ProfileCompilationInfo::ContainsClass(const DexFile& dex_file, dex::TypeIndex type_idx) const {
   auto info_it = info_.find(GetProfileDexFileKey(dex_file.GetLocation()));
   if (info_it != info_.end()) {
@@ -584,7 +904,7 @@
 uint32_t ProfileCompilationInfo::GetNumberOfMethods() const {
   uint32_t total = 0;
   for (const auto& it : info_) {
-    total += it.second.method_set.size();
+    total += it.second.method_map.size();
   }
   return total;
 }
@@ -645,19 +965,34 @@
       }
     }
     os << "\n\tmethods: ";
-    for (const auto method_it : dex_data.method_set) {
+    for (const auto method_it : dex_data.method_map) {
       if (dex_file != nullptr) {
-        os << "\n\t\t" << dex_file->PrettyMethod(method_it, true);
+        os << "\n\t\t" << dex_file->PrettyMethod(method_it.first, true);
       } else {
-        os << method_it << ",";
+        os << method_it.first;
       }
+
+      os << "[";
+      for (const auto& inline_cache_it : method_it.second) {
+        os << "{" << std::hex << inline_cache_it.first << std::dec << ":";
+        if (inline_cache_it.second.is_megamorphic) {
+          os << "M";
+        } else {
+          for (const ClassReference& class_ref : inline_cache_it.second.classes) {
+            os << "(" << static_cast<uint32_t>(class_ref.dex_profile_index)
+               << "," << class_ref.type_index.index_ << ")";
+          }
+        }
+        os << "}";
+      }
+      os << "], ";
     }
     os << "\n\tclasses: ";
     for (const auto class_it : dex_data.class_set) {
       if (dex_file != nullptr) {
         os << "\n\t\t" << dex_file->PrettyType(class_it);
       } else {
-        os << class_it << ",";
+        os << class_it.index_ << ",";
       }
     }
   }
@@ -762,4 +1097,44 @@
   return info.Save(fd);
 }
 
+bool ProfileCompilationInfo::OfflineProfileMethodInfo::operator==(
+      const OfflineProfileMethodInfo& other) const {
+  if (inline_caches.size() != other.inline_caches.size()) {
+    return false;
+  }
+
+  // We can't use a simple equality test because we need to match the dex files
+  // of the inline caches which might have different profile indices.
+  for (const auto& inline_cache_it : inline_caches) {
+    uint16_t dex_pc = inline_cache_it.first;
+    const DexPcData dex_pc_data = inline_cache_it.second;
+    const auto other_it = other.inline_caches.find(dex_pc);
+    if (other_it == other.inline_caches.end()) {
+      return false;
+    }
+    const DexPcData& other_dex_pc_data = other_it->second;
+    if (dex_pc_data.is_megamorphic != other_dex_pc_data.is_megamorphic) {
+      return false;
+    }
+    for (const ClassReference& class_ref : dex_pc_data.classes) {
+      bool found = false;
+      for (const ClassReference& other_class_ref : other_dex_pc_data.classes) {
+        CHECK_LE(class_ref.dex_profile_index, dex_references.size());
+        CHECK_LE(other_class_ref.dex_profile_index, other.dex_references.size());
+        const DexReference& dex_ref = dex_references[class_ref.dex_profile_index];
+        const DexReference& other_dex_ref = other.dex_references[other_class_ref.dex_profile_index];
+        if (class_ref.type_index == other_class_ref.type_index &&
+            dex_ref == other_dex_ref) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 }  // namespace art
diff --git a/runtime/jit/profile_compilation_info.h b/runtime/jit/profile_compilation_info.h
index 758b46d..4bfbfcd 100644
--- a/runtime/jit/profile_compilation_info.h
+++ b/runtime/jit/profile_compilation_info.h
@@ -31,6 +31,40 @@
 namespace art {
 
 /**
+ *  Convenient class to pass around profile information (including inline caches)
+ *  without the need to hold GC-able objects.
+ */
+struct ProfileMethodInfo {
+  struct ProfileClassReference {
+    ProfileClassReference(const DexFile* dex, const dex::TypeIndex& index)
+        : dex_file(dex), type_index(index) {}
+
+    const DexFile* dex_file;
+    const dex::TypeIndex type_index;
+  };
+
+  struct ProfileInlineCache {
+    ProfileInlineCache(uint32_t pc, const std::vector<ProfileClassReference>& profile_classes)
+        : dex_pc(pc), classes(profile_classes) {}
+
+    const uint32_t dex_pc;
+    const std::vector<ProfileClassReference> classes;
+  };
+
+  ProfileMethodInfo(const DexFile* dex, uint32_t method_index)
+      : dex_file(dex), dex_method_index(method_index) {}
+
+  ProfileMethodInfo(const DexFile* dex,
+                    uint32_t method_index,
+                    const std::vector<ProfileInlineCache>& caches)
+      : dex_file(dex), dex_method_index(method_index), inline_caches(caches) {}
+
+  const DexFile* dex_file;
+  const uint32_t dex_method_index;
+  const std::vector<ProfileInlineCache> inline_caches;
+};
+
+/**
  * Profile information in a format suitable to be queried by the compiler and
  * performing profile guided compilation.
  * It is a serialize-friendly format based on information collected by the
@@ -42,34 +76,130 @@
   static const uint8_t kProfileMagic[];
   static const uint8_t kProfileVersion[];
 
+  // Data structures for encoding the offline representation of inline caches.
+  // This is exposed as public in order to make it available to dex2oat compilations
+  // (see compiler/optimizing/inliner.cc).
+
+  // A dex location together with its checksum.
+  struct DexReference {
+    DexReference() {}
+
+    DexReference(const std::string& location, uint32_t checksum)
+        : dex_location(location), dex_checksum(checksum) {}
+
+    bool operator==(const DexReference& other) const {
+      return dex_checksum == other.dex_checksum && dex_location == other.dex_location;
+    }
+
+    std::string dex_location;
+    uint32_t dex_checksum;
+  };
+
+  // Encodes a class reference in the profile.
+  // The owning dex file is encoded as the index (dex_profile_index) it has in the
+  // profile rather than as a full DexRefence(location,checksum).
+  // This avoids excessive string copying when managing the profile data.
+  // The dex_profile_index is an index in either of:
+  //  - OfflineProfileMethodInfo#dex_references vector (public use)
+  //  - DexFileData#profile_index (internal use).
+  // Note that the dex_profile_index is not necessary the multidex index.
+  // We cannot rely on the actual multidex index because a single profile may store
+  // data from multiple splits. This means that a profile may contain a classes2.dex from split-A
+  // and one from split-B.
+  struct ClassReference {
+    ClassReference(uint8_t dex_profile_idx, const dex::TypeIndex& type_idx) :
+      dex_profile_index(dex_profile_idx), type_index(type_idx) {}
+
+    bool operator==(const ClassReference& other) const {
+      return dex_profile_index == other.dex_profile_index && type_index == other.type_index;
+    }
+    bool operator<(const ClassReference& other) const {
+      return dex_profile_index == other.dex_profile_index
+          ? type_index < other.type_index
+          : dex_profile_index < other.dex_profile_index;
+    }
+
+    uint8_t dex_profile_index;  // the index of the owning dex in the profile info
+    dex::TypeIndex type_index;  // the type index of the class
+  };
+
+  // The set of classes that can be found at a given dex pc.
+  using ClassSet = std::set<ClassReference>;
+
+  // Encodes the actual inline cache for a given dex pc (whether or not the receiver is
+  // megamorphic and its possible types).
+  // If the receiver is megamorphic the set of classes will be empty.
+  struct DexPcData {
+    DexPcData() : is_megamorphic(false) {}
+    void AddClass(uint16_t dex_profile_idx, const dex::TypeIndex& type_idx);
+    void SetMegamorphic() {
+      is_megamorphic = true;
+      classes.clear();
+    }
+    bool operator==(const DexPcData& other) const {
+      return is_megamorphic == other.is_megamorphic && classes == other.classes;
+    }
+
+    bool is_megamorphic;
+    ClassSet classes;
+  };
+
+  // The inline cache map: DexPc -> DexPcData.
+  using InlineCacheMap = SafeMap<uint16_t, DexPcData>;
+
+  // Encodes the full set of inline caches for a given method.
+  // The dex_references vector is indexed according to the ClassReference::dex_profile_index.
+  // i.e. the dex file of any ClassReference present in the inline caches can be found at
+  // dex_references[ClassReference::dex_profile_index].
+  struct OfflineProfileMethodInfo {
+    bool operator==(const OfflineProfileMethodInfo& other) const;
+
+    std::vector<DexReference> dex_references;
+    InlineCacheMap inline_caches;
+  };
+
+  // Public methods to create, extend or query the profile.
+
   // Add the given methods and classes to the current profile object.
-  bool AddMethodsAndClasses(const std::vector<MethodReference>& methods,
+  bool AddMethodsAndClasses(const std::vector<ProfileMethodInfo>& methods,
                             const std::set<DexCacheResolvedClasses>& resolved_classes);
-  // Loads profile information from the given file descriptor.
+
+  // Load profile information from the given file descriptor.
   bool Load(int fd);
+
   // Merge the data from another ProfileCompilationInfo into the current object.
   bool MergeWith(const ProfileCompilationInfo& info);
-  // Saves the profile data to the given file descriptor.
+
+  // Save the profile data to the given file descriptor.
   bool Save(int fd);
-  // Loads and merges profile information from the given file into the current
+
+  // Load and merge profile information from the given file into the current
   // object and tries to save it back to disk.
   // If `force` is true then the save will go through even if the given file
   // has bad data or its version does not match. In this cases the profile content
   // is ignored.
   bool MergeAndSave(const std::string& filename, uint64_t* bytes_written, bool force);
 
-  // Returns the number of methods that were profiled.
+  // Return the number of methods that were profiled.
   uint32_t GetNumberOfMethods() const;
-  // Returns the number of resolved classes that were profiled.
+
+  // Return the number of resolved classes that were profiled.
   uint32_t GetNumberOfResolvedClasses() const;
 
-  // Returns true if the method reference is present in the profiling info.
+  // Return true if the method reference is present in the profiling info.
   bool ContainsMethod(const MethodReference& method_ref) const;
 
-  // Returns true if the class's type is present in the profiling info.
+  // Return true if the class's type is present in the profiling info.
   bool ContainsClass(const DexFile& dex_file, dex::TypeIndex type_idx) const;
 
-  // Dumps all the loaded profile info into a string and returns it.
+  // Return true if the method is present in the profiling info.
+  // If the method is found, `pmi` is populated with its inline caches.
+  bool GetMethod(const std::string& dex_location,
+                 uint32_t dex_checksum,
+                 uint16_t dex_method_index,
+                 /*out*/OfflineProfileMethodInfo* pmi) const;
+
+  // Dump all the loaded profile info into a string and returns it.
   // If dex_files is not null then the method indices will be resolved to their
   // names.
   // This is intended for testing and debugging.
@@ -80,26 +210,35 @@
 
   void GetClassNames(const std::vector<std::unique_ptr<const DexFile>>* dex_files,
                      std::set<std::string>* class_names) const;
+
   void GetClassNames(const std::vector<const DexFile*>* dex_files,
                      std::set<std::string>* class_names) const;
 
+  // Perform an equality test with the `other` profile information.
   bool Equals(const ProfileCompilationInfo& other);
 
-  static std::string GetProfileDexFileKey(const std::string& dex_location);
-
-  // Returns the class descriptors for all of the classes in the profiles' class sets.
+  // Return the class descriptors for all of the classes in the profiles' class sets.
   // Note the dex location is actually the profile key, the caller needs to call back in to the
   // profile info stuff to generate a map back to the dex location.
   std::set<DexCacheResolvedClasses> GetResolvedClasses() const;
 
-  // Clears the resolved classes from the current object.
+  // Clear the resolved classes from the current object.
   void ClearResolvedClasses();
 
+  // Return the profile key associated with the given dex location.
+  static std::string GetProfileDexFileKey(const std::string& dex_location);
+
+  // Generate a test profile which will contain a percentage of the total maximum
+  // number of methods and classes (method_ratio and class_ratio).
   static bool GenerateTestProfile(int fd,
                                   uint16_t number_of_dex_files,
                                   uint16_t method_ratio,
                                   uint16_t class_ratio);
 
+  // Check that the given profile method info contain the same data.
+  static bool Equals(const ProfileCompilationInfo::OfflineProfileMethodInfo& pmi1,
+                     const ProfileCompilationInfo::OfflineProfileMethodInfo& pmi2);
+
  private:
   enum ProfileLoadSatus {
     kProfileLoadIOError,
@@ -108,30 +247,71 @@
     kProfileLoadSuccess
   };
 
+  // Maps a method dex index to its inline cache.
+  using MethodMap = SafeMap<uint16_t, InlineCacheMap>;
+
+  // Internal representation of the profile information belonging to a dex file.
   struct DexFileData {
-    explicit DexFileData(uint32_t location_checksum) : checksum(location_checksum) {}
+    DexFileData(uint32_t location_checksum, uint16_t index)
+         : profile_index(index), checksum(location_checksum) {}
+    // The profile index of this dex file (matches ClassReference#dex_profile_index)
+    uint8_t profile_index;
+    // The dex checksum
     uint32_t checksum;
-    std::set<uint16_t> method_set;
+    // The methonds' profile information
+    MethodMap method_map;
+    // The classes which have been profiled. Note that these don't necessarily include
+    // all the classes that can be found in the inline caches reference.
     std::set<dex::TypeIndex> class_set;
 
     bool operator==(const DexFileData& other) const {
-      return checksum == other.checksum && method_set == other.method_set;
+      return checksum == other.checksum && method_map == other.method_map;
     }
   };
 
+  // Maps dex file to their profile information.
   using DexFileToProfileInfoMap = SafeMap<const std::string, DexFileData>;
 
+  // Return the profile data for the given dex location or null if the dex location
+  // already exists but has a different checksum
   DexFileData* GetOrAddDexFileData(const std::string& dex_location, uint32_t checksum);
+
+  // Add a method index to the profile (without inline caches).
   bool AddMethodIndex(const std::string& dex_location, uint32_t checksum, uint16_t method_idx);
+
+  // Add a method to the profile using its online representation (containing runtime structures).
+  bool AddMethod(const ProfileMethodInfo& pmi);
+
+  // Add a method to the profile using its offline representation.
+  // This is mostly used to facilitate testing.
+  bool AddMethod(const std::string& dex_location,
+                 uint32_t dex_checksum,
+                 uint16_t method_index,
+                 const OfflineProfileMethodInfo& pmi);
+
+  // Add a class index to the profile.
   bool AddClassIndex(const std::string& dex_location, uint32_t checksum, dex::TypeIndex type_idx);
+
+  // Add all classes from the given dex cache to the the profile.
   bool AddResolvedClasses(const DexCacheResolvedClasses& classes);
 
+  // Search for the given method in the profile.
+  // If found, its inline cache map is returned, otherwise the method returns null.
+  const InlineCacheMap* FindMethod(const std::string& dex_location,
+                                   uint32_t dex_checksum,
+                                   uint16_t dex_method_index) const;
+
+  // Encode the known dex_files into a vector. The index of a dex_reference will
+  // be the same as the profile index of the dex file (used to encode the ClassReferences).
+  void DexFileToProfileIndex(/*out*/std::vector<DexReference>* dex_references) const;
+
   // Parsing functionality.
 
+  // The information present in the header of each profile line.
   struct ProfileLineHeader {
     std::string dex_location;
-    uint16_t method_set_size;
     uint16_t class_set_size;
+    uint32_t method_region_size_bytes;
     uint32_t checksum;
   };
 
@@ -150,12 +330,15 @@
 
     // Reads an uint value (high bits to low bits) and advances the current pointer
     // with the number of bits read.
-    template <typename T> T ReadUintAndAdvance();
+    template <typename T> bool ReadUintAndAdvance(/*out*/ T* value);
 
     // Compares the given data with the content current pointer. If the contents are
     // equal it advances the current pointer by data_size.
     bool CompareAndAdvance(const uint8_t* data, size_t data_size);
 
+    // Returns true if the buffer has more data to read.
+    bool HasMoreData();
+
     // Get the underlying raw buffer.
     uint8_t* Get() { return storage_.get(); }
 
@@ -165,24 +348,63 @@
     uint8_t* ptr_end_;
   };
 
+  // Entry point for profile loding functionality.
   ProfileLoadSatus LoadInternal(int fd, std::string* error);
 
+  // Read the profile header from the given fd and store the number of profile
+  // lines into number_of_dex_files.
   ProfileLoadSatus ReadProfileHeader(int fd,
-                                     /*out*/uint16_t* number_of_lines,
+                                     /*out*/uint8_t* number_of_dex_files,
                                      /*out*/std::string* error);
 
+  // Read the header of a profile line from the given fd.
   ProfileLoadSatus ReadProfileLineHeader(int fd,
                                          /*out*/ProfileLineHeader* line_header,
                                          /*out*/std::string* error);
+
+  // Read individual elements from the profile line header.
+  bool ReadProfileLineHeaderElements(SafeBuffer& buffer,
+                                     /*out*/uint16_t* dex_location_size,
+                                     /*out*/ProfileLineHeader* line_header,
+                                     /*out*/std::string* error);
+
+  // Read a single profile line from the given fd.
   ProfileLoadSatus ReadProfileLine(int fd,
+                                   uint8_t number_of_dex_files,
                                    const ProfileLineHeader& line_header,
                                    /*out*/std::string* error);
 
-  bool ProcessLine(SafeBuffer& line_buffer,
-                   uint16_t method_set_size,
-                   uint16_t class_set_size,
-                   uint32_t checksum,
-                   const std::string& dex_location);
+  // Read all the classes from the buffer into the profile `info_` structure.
+  bool ReadClasses(SafeBuffer& buffer,
+                   uint16_t classes_to_read,
+                   const ProfileLineHeader& line_header,
+                   /*out*/std::string* error);
+
+  // Read all the methods from the buffer into the profile `info_` structure.
+  bool ReadMethods(SafeBuffer& buffer,
+                   uint8_t number_of_dex_files,
+                   const ProfileLineHeader& line_header,
+                   /*out*/std::string* error);
+
+  // Read the inline cache encoding from line_bufer into inline_cache.
+  bool ReadInlineCache(SafeBuffer& buffer,
+                       uint8_t number_of_dex_files,
+                       /*out*/InlineCacheMap* inline_cache,
+                       /*out*/std::string* error);
+
+  // Encode the inline cache into the given buffer.
+  void AddInlineCacheToBuffer(std::vector<uint8_t>* buffer,
+                              const InlineCacheMap& inline_cache);
+
+  // Return the number of bytes needed to encode the profile information
+  // for the methods in dex_data.
+  uint32_t GetMethodsRegionSize(const DexFileData& dex_data);
+
+  // Group `classes` by their owning dex profile index and put the result in
+  // `dex_to_classes_map`.
+  void GroupClassesByDex(
+      const ClassSet& classes,
+      /*out*/SafeMap<uint8_t, std::vector<dex::TypeIndex>>* dex_to_classes_map);
 
   friend class ProfileCompilationInfoTest;
   friend class CompilerDriverProfileTest;
diff --git a/runtime/jit/profile_compilation_info_test.cc b/runtime/jit/profile_compilation_info_test.cc
index 835a5f3..93b47ac 100644
--- a/runtime/jit/profile_compilation_info_test.cc
+++ b/runtime/jit/profile_compilation_info_test.cc
@@ -57,6 +57,14 @@
     return info->AddMethodIndex(dex_location, checksum, method_index);
   }
 
+  bool AddMethod(const std::string& dex_location,
+                 uint32_t checksum,
+                 uint16_t method_index,
+                 const ProfileCompilationInfo::OfflineProfileMethodInfo& pmi,
+                 ProfileCompilationInfo* info) {
+    return info->AddMethod(dex_location, checksum, method_index, pmi);
+  }
+
   bool AddClass(const std::string& dex_location,
                 uint32_t checksum,
                 uint16_t class_index,
@@ -73,17 +81,132 @@
       const std::vector<ArtMethod*>& methods,
       const std::set<DexCacheResolvedClasses>& resolved_classes) {
     ProfileCompilationInfo info;
-    std::vector<MethodReference> method_refs;
+    std::vector<ProfileMethodInfo> profile_methods;
     ScopedObjectAccess soa(Thread::Current());
     for (ArtMethod* method : methods) {
-      method_refs.emplace_back(method->GetDexFile(), method->GetDexMethodIndex());
+      profile_methods.emplace_back(method->GetDexFile(), method->GetDexMethodIndex());
     }
-    if (!info.AddMethodsAndClasses(method_refs, resolved_classes)) {
+    if (!info.AddMethodsAndClasses(profile_methods, resolved_classes)) {
+      return false;
+    }
+    if (info.GetNumberOfMethods() != profile_methods.size()) {
       return false;
     }
     return info.MergeAndSave(filename, nullptr, false);
   }
 
+  // Saves the given art methods to a profile backed by 'filename' and adds
+  // some fake inline caches to it. The added inline caches are returned in
+  // the out map `profile_methods_map`.
+  bool SaveProfilingInfoWithFakeInlineCaches(
+      const std::string& filename,
+      const std::vector<ArtMethod*>& methods,
+      /*out*/ SafeMap<ArtMethod*, ProfileMethodInfo>* profile_methods_map) {
+    ProfileCompilationInfo info;
+    std::vector<ProfileMethodInfo> profile_methods;
+    ScopedObjectAccess soa(Thread::Current());
+    for (ArtMethod* method : methods) {
+      std::vector<ProfileMethodInfo::ProfileInlineCache> caches;
+      // Monomorphic
+      for (uint16_t dex_pc = 0; dex_pc < 1; dex_pc++) {
+        std::vector<ProfileMethodInfo::ProfileClassReference> classes;
+        classes.emplace_back(method->GetDexFile(), dex::TypeIndex(0));
+        caches.emplace_back(dex_pc, classes);
+      }
+      // Polymorphic
+      for (uint16_t dex_pc = 1; dex_pc < 2; dex_pc++) {
+        std::vector<ProfileMethodInfo::ProfileClassReference> classes;
+        for (uint16_t k = 0; k < InlineCache::kIndividualCacheSize / 2; k++) {
+          classes.emplace_back(method->GetDexFile(), dex::TypeIndex(k));
+        }
+        caches.emplace_back(dex_pc, classes);
+      }
+      // Megamorphic
+      for (uint16_t dex_pc = 2; dex_pc < 3; dex_pc++) {
+        std::vector<ProfileMethodInfo::ProfileClassReference> classes;
+        for (uint16_t k = 0; k < 2 * InlineCache::kIndividualCacheSize; k++) {
+          classes.emplace_back(method->GetDexFile(), dex::TypeIndex(k));
+        }
+        caches.emplace_back(dex_pc, classes);
+      }
+      ProfileMethodInfo pmi(method->GetDexFile(), method->GetDexMethodIndex(), caches);
+      profile_methods.push_back(pmi);
+      profile_methods_map->Put(method, pmi);
+    }
+
+    if (!info.AddMethodsAndClasses(profile_methods, std::set<DexCacheResolvedClasses>())) {
+      return false;
+    }
+    if (info.GetNumberOfMethods() != profile_methods.size()) {
+      return false;
+    }
+    return info.MergeAndSave(filename, nullptr, false);
+  }
+
+  ProfileCompilationInfo::OfflineProfileMethodInfo ConvertProfileMethodInfo(
+        const ProfileMethodInfo& pmi) {
+    ProfileCompilationInfo::OfflineProfileMethodInfo offline_pmi;
+    SafeMap<DexFile*, uint8_t> dex_map;  // dex files to profile index
+    for (const auto& inline_cache : pmi.inline_caches) {
+      for (const auto& class_ref : inline_cache.classes) {
+        uint8_t dex_profile_index = dex_map.FindOrAdd(const_cast<DexFile*>(class_ref.dex_file),
+                                                      static_cast<uint8_t>(dex_map.size()))->second;
+        offline_pmi.inline_caches
+            .FindOrAdd(inline_cache.dex_pc)->second
+            .AddClass(dex_profile_index, class_ref.type_index);
+        if (dex_profile_index >= offline_pmi.dex_references.size()) {
+          // This is a new dex.
+          const std::string& dex_key = ProfileCompilationInfo::GetProfileDexFileKey(
+              class_ref.dex_file->GetLocation());
+          offline_pmi.dex_references.emplace_back(dex_key,
+                                                  class_ref.dex_file->GetLocationChecksum());
+        }
+      }
+    }
+    return offline_pmi;
+  }
+
+  // Creates an offline profile used for testing inline caches.
+  ProfileCompilationInfo::OfflineProfileMethodInfo GetOfflineProfileMethodInfo() {
+    ProfileCompilationInfo::OfflineProfileMethodInfo pmi;
+
+    pmi.dex_references.emplace_back("dex_location1", /* checksum */ 1);
+    pmi.dex_references.emplace_back("dex_location2", /* checksum */ 2);
+    pmi.dex_references.emplace_back("dex_location3", /* checksum */ 3);
+
+    // Monomorphic
+    for (uint16_t dex_pc = 0; dex_pc < 1; dex_pc++) {
+      ProfileCompilationInfo::DexPcData dex_pc_data;
+      dex_pc_data.AddClass(0, dex::TypeIndex(0));
+      pmi.inline_caches.Put(dex_pc, dex_pc_data);
+    }
+    // Polymorphic
+    for (uint16_t dex_pc = 1; dex_pc < 2; dex_pc++) {
+      ProfileCompilationInfo::DexPcData dex_pc_data;
+      dex_pc_data.AddClass(0, dex::TypeIndex(0));
+      dex_pc_data.AddClass(1, dex::TypeIndex(1));
+      dex_pc_data.AddClass(2, dex::TypeIndex(2));
+
+       pmi.inline_caches.Put(dex_pc, dex_pc_data);
+    }
+    // Megamorphic
+    for (uint16_t dex_pc = 2; dex_pc < 3; dex_pc++) {
+      ProfileCompilationInfo::DexPcData dex_pc_data;
+      dex_pc_data.is_megamorphic = true;
+      pmi.inline_caches.Put(dex_pc, dex_pc_data);
+    }
+
+    return pmi;
+  }
+
+  void MakeMegamorphic(/*out*/ProfileCompilationInfo::OfflineProfileMethodInfo* pmi) {
+    for (auto it : pmi->inline_caches) {
+      for (uint16_t k = 0; k <= 2 * InlineCache::kIndividualCacheSize; k++) {
+        it.second.AddClass(0, dex::TypeIndex(k));
+      }
+    }
+  }
+
   // Cannot sizeof the actual arrays so hardcode the values here.
   // They should not change anyway.
   static constexpr int kProfileMagicSize = 4;
@@ -235,12 +358,12 @@
 TEST_F(ProfileCompilationInfoTest, LoadEmpty) {
   ScratchFile profile;
 
-  ProfileCompilationInfo empyt_info;
+  ProfileCompilationInfo empty_info;
 
   ProfileCompilationInfo loaded_info;
   ASSERT_TRUE(profile.GetFile()->ResetOffset());
   ASSERT_TRUE(loaded_info.Load(GetFd(profile)));
-  ASSERT_TRUE(loaded_info.Equals(empyt_info));
+  ASSERT_TRUE(loaded_info.Equals(empty_info));
 }
 
 TEST_F(ProfileCompilationInfoTest, BadMagic) {
@@ -324,4 +447,214 @@
   ASSERT_FALSE(loaded_info.Load(GetFd(profile)));
 }
 
+TEST_F(ProfileCompilationInfoTest, SaveInlineCaches) {
+  ScratchFile profile;
+
+  ProfileCompilationInfo saved_info;
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi = GetOfflineProfileMethodInfo();
+
+  // Add methods with inline caches.
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    // Add a method which is part of the same dex file as one of the
+    // class from the inline caches.
+    ASSERT_TRUE(AddMethod("dex_location1", /* checksum */ 1, method_idx, pmi, &saved_info));
+    // Add a method which is outside the set of dex files.
+    ASSERT_TRUE(AddMethod("dex_location4", /* checksum */ 4, method_idx, pmi, &saved_info));
+  }
+
+  ASSERT_TRUE(saved_info.Save(GetFd(profile)));
+  ASSERT_EQ(0, profile.GetFile()->Flush());
+
+  // Check that we get back what we saved.
+  ProfileCompilationInfo loaded_info;
+  ASSERT_TRUE(profile.GetFile()->ResetOffset());
+  ASSERT_TRUE(loaded_info.Load(GetFd(profile)));
+
+  ASSERT_TRUE(loaded_info.Equals(saved_info));
+
+  ProfileCompilationInfo::OfflineProfileMethodInfo loaded_pmi1;
+  ASSERT_TRUE(loaded_info.GetMethod("dex_location1",
+                                    /* checksum */ 1,
+                                    /* method_idx */ 3,
+                                    &loaded_pmi1));
+  ASSERT_TRUE(loaded_pmi1 == pmi);
+  ProfileCompilationInfo::OfflineProfileMethodInfo loaded_pmi2;
+  ASSERT_TRUE(loaded_info.GetMethod("dex_location4",
+                                    /* checksum */ 4,
+                                    /* method_idx */ 3,
+                                    &loaded_pmi2));
+  ASSERT_TRUE(loaded_pmi2 == pmi);
+}
+
+TEST_F(ProfileCompilationInfoTest, MegamorphicInlineCaches) {
+  ScratchFile profile;
+
+  ProfileCompilationInfo saved_info;
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi = GetOfflineProfileMethodInfo();
+
+  // Add methods with inline caches.
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    ASSERT_TRUE(AddMethod("dex_location1", /* checksum */ 1, method_idx, pmi, &saved_info));
+  }
+
+  ASSERT_TRUE(saved_info.Save(GetFd(profile)));
+  ASSERT_EQ(0, profile.GetFile()->Flush());
+
+  // Make the inline caches megamorphic and add them to the profile again.
+  ProfileCompilationInfo saved_info_extra;
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi_extra = GetOfflineProfileMethodInfo();
+  MakeMegamorphic(&pmi_extra);
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    ASSERT_TRUE(AddMethod("dex_location1", /* checksum */ 1, method_idx, pmi, &saved_info_extra));
+  }
+
+  ASSERT_TRUE(profile.GetFile()->ResetOffset());
+  ASSERT_TRUE(saved_info_extra.Save(GetFd(profile)));
+  ASSERT_EQ(0, profile.GetFile()->Flush());
+
+  // Merge the profiles so that we have the same view as the file.
+  ASSERT_TRUE(saved_info.MergeWith(saved_info_extra));
+
+  // Check that we get back what we saved.
+  ProfileCompilationInfo loaded_info;
+  ASSERT_TRUE(profile.GetFile()->ResetOffset());
+  ASSERT_TRUE(loaded_info.Load(GetFd(profile)));
+
+  ASSERT_TRUE(loaded_info.Equals(saved_info));
+
+  ProfileCompilationInfo::OfflineProfileMethodInfo loaded_pmi1;
+  ASSERT_TRUE(loaded_info.GetMethod("dex_location1",
+                                    /* checksum */ 1,
+                                    /* method_idx */ 3,
+                                    &loaded_pmi1));
+  ASSERT_TRUE(loaded_pmi1 == pmi_extra);
+}
+
+TEST_F(ProfileCompilationInfoTest, SaveArtMethodsWithInlineCaches) {
+  ScratchFile profile;
+
+  Thread* self = Thread::Current();
+  jobject class_loader;
+  {
+    ScopedObjectAccess soa(self);
+    class_loader = LoadDex("ProfileTestMultiDex");
+  }
+  ASSERT_NE(class_loader, nullptr);
+
+  // Save virtual methods from Main.
+  std::set<DexCacheResolvedClasses> resolved_classes;
+  std::vector<ArtMethod*> main_methods = GetVirtualMethods(class_loader, "LMain;");
+
+  SafeMap<ArtMethod*, ProfileMethodInfo> profile_methods_map;
+  ASSERT_TRUE(SaveProfilingInfoWithFakeInlineCaches(
+      profile.GetFilename(), main_methods,  &profile_methods_map));
+
+  // Check that what we saved is in the profile.
+  ProfileCompilationInfo info;
+  ASSERT_TRUE(info.Load(GetFd(profile)));
+  ASSERT_EQ(info.GetNumberOfMethods(), main_methods.size());
+  {
+    ScopedObjectAccess soa(self);
+    for (ArtMethod* m : main_methods) {
+      ASSERT_TRUE(info.ContainsMethod(MethodReference(m->GetDexFile(), m->GetDexMethodIndex())));
+      const ProfileMethodInfo& pmi = profile_methods_map.find(m)->second;
+      ProfileCompilationInfo::OfflineProfileMethodInfo offline_pmi;
+      ASSERT_TRUE(info.GetMethod(m->GetDexFile()->GetLocation(),
+                                 m->GetDexFile()->GetLocationChecksum(),
+                                 m->GetDexMethodIndex(),
+                                 &offline_pmi));
+      ProfileCompilationInfo::OfflineProfileMethodInfo converted_pmi =
+          ConvertProfileMethodInfo(pmi);
+      ASSERT_EQ(converted_pmi, offline_pmi);
+    }
+  }
+}
+
+TEST_F(ProfileCompilationInfoTest, InvalidChecksumInInlineCahce) {
+  ScratchFile profile;
+
+  ProfileCompilationInfo info;
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi1 = GetOfflineProfileMethodInfo();
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi2 = GetOfflineProfileMethodInfo();
+  // Modify the checksum to trigger a mismatch.
+  pmi2.dex_references[0].dex_checksum++;
+
+  ASSERT_TRUE(AddMethod("dex_location1", /* checksum */ 1, /*method_idx*/ 0, pmi1, &info));
+  ASSERT_FALSE(AddMethod("dex_location2", /* checksum */ 2, /*method_idx*/ 0, pmi2, &info));
+}
+
+// Verify that profiles behave correctly even if the methods are added in a different
+// order and with a different dex profile indices for the dex files.
+TEST_F(ProfileCompilationInfoTest, MergeInlineCacheTriggerReindex) {
+  ScratchFile profile;
+
+  ProfileCompilationInfo info;
+  ProfileCompilationInfo info_reindexed;
+
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi;
+  pmi.dex_references.emplace_back("dex_location1", /* checksum */ 1);
+  pmi.dex_references.emplace_back("dex_location2", /* checksum */ 2);
+  for (uint16_t dex_pc = 1; dex_pc < 5; dex_pc++) {
+    ProfileCompilationInfo::DexPcData dex_pc_data;
+    dex_pc_data.AddClass(0, dex::TypeIndex(0));
+    dex_pc_data.AddClass(1, dex::TypeIndex(1));
+    pmi.inline_caches.Put(dex_pc, dex_pc_data);
+  }
+
+  ProfileCompilationInfo::OfflineProfileMethodInfo pmi_reindexed;
+  pmi_reindexed.dex_references.emplace_back("dex_location2", /* checksum */ 2);
+  pmi_reindexed.dex_references.emplace_back("dex_location1", /* checksum */ 1);
+  for (uint16_t dex_pc = 1; dex_pc < 5; dex_pc++) {
+    ProfileCompilationInfo::DexPcData dex_pc_data;
+    dex_pc_data.AddClass(1, dex::TypeIndex(0));
+    dex_pc_data.AddClass(0, dex::TypeIndex(1));
+    pmi_reindexed.inline_caches.Put(dex_pc, dex_pc_data);
+  }
+
+  // Profile 1 and Profile 2 get the same methods but in different order.
+  // This will trigger a different dex numbers.
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    ASSERT_TRUE(AddMethod("dex_location1", /* checksum */ 1, method_idx, pmi, &info));
+    ASSERT_TRUE(AddMethod("dex_location2", /* checksum */ 2, method_idx, pmi, &info));
+  }
+
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    ASSERT_TRUE(AddMethod(
+      "dex_location2", /* checksum */ 2, method_idx, pmi_reindexed, &info_reindexed));
+    ASSERT_TRUE(AddMethod(
+      "dex_location1", /* checksum */ 1, method_idx, pmi_reindexed, &info_reindexed));
+  }
+
+  ProfileCompilationInfo info_backup = info;
+  ASSERT_TRUE(info.MergeWith(info_reindexed));
+  // Merging should have no effect as we're adding the exact same stuff.
+  ASSERT_TRUE(info.Equals(info_backup));
+  for (uint16_t method_idx = 0; method_idx < 10; method_idx++) {
+    ProfileCompilationInfo::OfflineProfileMethodInfo loaded_pmi1;
+    ASSERT_TRUE(info.GetMethod("dex_location1",
+                                      /* checksum */ 1,
+                                      /* method_idx */ method_idx,
+                                      &loaded_pmi1));
+    ASSERT_TRUE(loaded_pmi1 == pmi);
+    ProfileCompilationInfo::OfflineProfileMethodInfo loaded_pmi2;
+    ASSERT_TRUE(info.GetMethod("dex_location2",
+                                      /* checksum */ 2,
+                                      /* method_idx */ method_idx,
+                                      &loaded_pmi2));
+    ASSERT_TRUE(loaded_pmi2 == pmi);
+  }
+}
+
+TEST_F(ProfileCompilationInfoTest, AddMoreDexFileThanLimit) {
+  ProfileCompilationInfo info;
+  // Save a few methods.
+  for (uint16_t i = 0; i < std::numeric_limits<uint8_t>::max(); i++) {
+    std::string dex_location = std::to_string(i);
+    ASSERT_TRUE(AddMethod(dex_location, /* checksum */ 1, /* method_idx */ i, &info));
+  }
+  // We only support at most 255 dex files.
+  ASSERT_FALSE(AddMethod(
+      /*dex_location*/ "256", /* checksum */ 1, /* method_idx */ 0, &info));
+}
+
 }  // namespace art
diff --git a/runtime/jit/profile_saver.cc b/runtime/jit/profile_saver.cc
index 025d10c..61e6c41 100644
--- a/runtime/jit/profile_saver.cc
+++ b/runtime/jit/profile_saver.cc
@@ -236,10 +236,10 @@
     std::set<DexCacheResolvedClasses> resolved_classes_for_location;
     const std::string& filename = it.first;
     const std::set<std::string>& locations = it.second;
-    std::vector<MethodReference> methods_for_location;
+    std::vector<ProfileMethodInfo> profile_methods_for_location;
     for (const MethodReference& ref : methods) {
       if (locations.find(ref.dex_file->GetBaseLocation()) != locations.end()) {
-        methods_for_location.push_back(ref);
+        profile_methods_for_location.emplace_back(ref.dex_file, ref.dex_method_index);
       }
     }
     for (const DexCacheResolvedClasses& classes : resolved_classes) {
@@ -253,7 +253,7 @@
       }
     }
     ProfileCompilationInfo* info = GetCachedProfiledInfo(filename);
-    info->AddMethodsAndClasses(methods_for_location, resolved_classes_for_location);
+    info->AddMethodsAndClasses(profile_methods_for_location, resolved_classes_for_location);
     total_number_of_profile_entries_cached += resolved_classes_for_location.size();
   }
   max_number_of_profile_entries_cached_ = std::max(
@@ -280,15 +280,15 @@
     }
     const std::string& filename = it.first;
     const std::set<std::string>& locations = it.second;
-    std::vector<MethodReference> methods;
+    std::vector<ProfileMethodInfo> profile_methods;
     {
       ScopedObjectAccess soa(Thread::Current());
-      jit_code_cache_->GetProfiledMethods(locations, methods);
+      jit_code_cache_->GetProfiledMethods(locations, profile_methods);
       total_number_of_code_cache_queries_++;
     }
 
     ProfileCompilationInfo* cached_info = GetCachedProfiledInfo(filename);
-    cached_info->AddMethodsAndClasses(methods, std::set<DexCacheResolvedClasses>());
+    cached_info->AddMethodsAndClasses(profile_methods, std::set<DexCacheResolvedClasses>());
     int64_t delta_number_of_methods =
         cached_info->GetNumberOfMethods() -
         static_cast<int64_t>(last_save_number_of_methods_);
diff --git a/runtime/jit/profiling_info.h b/runtime/jit/profiling_info.h
index 1c58a83..f42a8da 100644
--- a/runtime/jit/profiling_info.h
+++ b/runtime/jit/profiling_info.h
@@ -39,7 +39,7 @@
 // Once the classes_ array is full, we consider the INVOKE to be megamorphic.
 class InlineCache {
  public:
-  static constexpr uint16_t kIndividualCacheSize = 5;
+  static constexpr uint8_t kIndividualCacheSize = 5;
 
  private:
   uint32_t dex_pc_;
diff --git a/runtime/safe_map.h b/runtime/safe_map.h
index 49f80f3..e638fdb 100644
--- a/runtime/safe_map.h
+++ b/runtime/safe_map.h
@@ -137,6 +137,16 @@
     return it->second;
   }
 
+  iterator FindOrAdd(const K& k, const V& v) {
+    iterator it = find(k);
+    return it == end() ? Put(k, v) : it;
+  }
+
+  iterator FindOrAdd(const K& k) {
+    iterator it = find(k);
+    return it == end() ? Put(k, V()) : it;
+  }
+
   bool Equals(const Self& rhs) const {
     return map_ == rhs.map_;
   }