Adding support for overlapping ranges to RangeMap.

src/processor/minidump.cc

 // Copyright (c) 2010 Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 2594 matching lines @@
 
       uint64_t base_address = module->base_address();
       uint64_t module_size = module->size();
       if (base_address == static_cast<uint64_t>(-1)) {
         BPLOG(ERROR) << "MinidumpModuleList found bad base address "
                         "for module " << module_index << "/" << module_count <<
                         ", " << module->code_file();
         return false;
       }
 
-      if (!range_map_->StoreRange(base_address, module_size, module_index)) {
+      if (!range_map_->StoreRange(base_address, 0 /* delta */, module_size,
+                                  module_index)) {
         // Android's shared memory implementation /dev/ashmem can contain
         // duplicate entries for JITted code, so ignore these.
         // TODO(wfh): Remove this code when Android is fixed.
         // See https://crbug.com/439531
         const string kDevAshmem("/dev/ashmem/");
         if (module->code_file().compare(
             0, kDevAshmem.length(), kDevAshmem) != 0) {
           if (base_address < last_end_address) {
             // If failed due to apparent range overlap the cause may be
             // the client correction applied for Android packed relocations.
             // If this is the case, back out the client correction and retry.
             module_size -= last_end_address - base_address;
             base_address = last_end_address;
-            if (!range_map_->StoreRange(base_address,
+            if (!range_map_->StoreRange(base_address, 0 /* delta */,
                                         module_size, module_index)) {
               BPLOG(ERROR) << "MinidumpModuleList could not store module " <<
                               module_index << "/" << module_count << ", " <<
                               module->code_file() << ", " <<
                               HexString(base_address) << "+" <<
                               HexString(module_size) << ", after adjusting";
               return false;
             }
           } else {
             BPLOG(ERROR) << "MinidumpModuleList could not store module " <<
@@ skipping 25 matching lines @@
 
 
 const MinidumpModule* MinidumpModuleList::GetModuleForAddress(
     uint64_t address) const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModuleList for GetModuleForAddress";
     return NULL;
   }
 
   unsigned int module_index;
-  if (!range_map_->RetrieveRange(address, &module_index, NULL, NULL)) {
+  if (!range_map_->RetrieveRange(address, &module_index, NULL, NULL, NULL)) {
     BPLOG(INFO) << "MinidumpModuleList has no module at " <<
                    HexString(address);
     return NULL;
   }
 
   return GetModuleAtIndex(module_index);
 }
 
 
 const MinidumpModule* MinidumpModuleList::GetMainModule() const {
@@ skipping 15 matching lines @@
     return NULL;
   }
 
   if (sequence >= module_count_) {
     BPLOG(ERROR) << "MinidumpModuleList sequence out of range: " <<
                     sequence << "/" << module_count_;
     return NULL;
   }
 
   unsigned int module_index;
-  if (!range_map_->RetrieveRangeAtIndex(sequence, &module_index, NULL, NULL)) {
+  if (!range_map_->RetrieveRangeAtIndex(sequence, &module_index, NULL, NULL,
+                                        NULL)) {
     BPLOG(ERROR) << "MinidumpModuleList has no module at sequence " << sequence;
     return NULL;
   }
 
   return GetModuleAtIndex(module_index);
 }
 
 
 const MinidumpModule* MinidumpModuleList::GetModuleAtIndex(
     unsigned int index) const {
@@ skipping 147 matching lines @@
       // Check for base + size overflow or undersize.
       if (region_size == 0 ||
           region_size > numeric_limits<uint64_t>::max() - base_address) {
         BPLOG(ERROR) << "MinidumpMemoryList has a memory region problem, " <<
                         " region " << region_index << "/" << region_count <<
                         ", " << HexString(base_address) << "+" <<
                         HexString(region_size);
         return false;
       }
 
-      if (!range_map_->StoreRange(base_address, region_size, region_index)) {
+      if (!range_map_->StoreRange(base_address, 0 /* delta */, region_size,
+                                  region_index)) {
         BPLOG(ERROR) << "MinidumpMemoryList could not store memory region " <<
                         region_index << "/" << region_count << ", " <<
                         HexString(base_address) << "+" <<
                         HexString(region_size);
         return false;
       }
 
       (*regions)[region_index].SetDescriptor(descriptor);
     }
 
@@ skipping 26 matching lines @@
 
 
 MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionForAddress(
     uint64_t address) {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryList for GetMemoryRegionForAddress";
     return NULL;
   }
 
   unsigned int region_index;
-  if (!range_map_->RetrieveRange(address, &region_index, NULL, NULL)) {
+  if (!range_map_->RetrieveRange(address, &region_index, NULL, NULL, NULL)) {
     BPLOG(INFO) << "MinidumpMemoryList has no memory region at " <<
                    HexString(address);
     return NULL;
   }
 
   return GetMemoryRegionAtIndex(region_index);
 }
 
 
 void MinidumpMemoryList::Print() {
@@ skipping 1037 matching lines @@
       // Assume that the file offset is correct after the last read.
       if (!info->Read()) {
         BPLOG(ERROR) << "MinidumpMemoryInfoList cannot read info " <<
                         index << "/" << header.number_of_entries;
         return false;
       }
 
       uint64_t base_address = info->GetBase();
       uint64_t region_size = info->GetSize();
 
-      if (!range_map_->StoreRange(base_address, region_size, index)) {
+      if (!range_map_->StoreRange(base_address, 0 /* delta */, region_size,
+                                  index)) {
         BPLOG(ERROR) << "MinidumpMemoryInfoList could not store"
                         " memory region " <<
                         index << "/" << header.number_of_entries << ", " <<
                         HexString(base_address) << "+" <<
                         HexString(region_size);
         return false;
       }
     }
 
     infos_ = infos.release();
@@ skipping 25 matching lines @@
 
 const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoForAddress(
     uint64_t address) const {
   if (!valid_) {
     BPLOG(ERROR) << "Invalid MinidumpMemoryInfoList for"
                     " GetMemoryInfoForAddress";
     return NULL;
   }
 
   unsigned int info_index;
-  if (!range_map_->RetrieveRange(address, &info_index, NULL, NULL)) {
+  if (!range_map_->RetrieveRange(address, &info_index, NULL, NULL, NULL)) {
     BPLOG(INFO) << "MinidumpMemoryInfoList has no memory info at " <<
                    HexString(address);
     return NULL;
   }
 
   return GetMemoryInfoAtIndex(info_index);
 }
 
 
 void MinidumpMemoryInfoList::Print() {
@@ skipping 824 matching lines @@
     return NULL;
   }
 
   *stream = new_stream.release();
   info->stream = *stream;
   return *stream;
 }
 
 
 }  // namespace google_breakpad