Server-side workaround to handle overlapping modules.

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 2091 matching lines @@
   // Mac OS X and Linux, instead of forcing them to adhere to the dotted
   // quad of 16-bit ints that Windows uses.
 
   BPLOG_IF(INFO, version.empty()) << "MinidumpModule could not determine "
                                      "version for " << *name_;
 
   return version;
 }
 
 
-const CodeModule* MinidumpModule::Copy() const {
+CodeModule* MinidumpModule::Copy() const {
   return new BasicCodeModule(this);
 }
 
 
+uint64_t MinidumpModule::shrink_down_delta() const {
+  return 0;
+}
+
+void MinidumpModule::SetShrinkDownDelta(uint64_t shrink_down_delta) {
+  // Not implemented
+  assert(false);
+}
+
+
 const uint8_t* MinidumpModule::GetCVRecord(uint32_t* size) {
   if (!module_valid_) {
     BPLOG(ERROR) << "Invalid MinidumpModule for GetCVRecord";
     return NULL;
   }
 
   if (!cv_record_) {
     // This just guards against 0-sized CodeView records; more specific checks
     // are used when the signature is checked against various structure types.
     if (module_.cv_record.data_size == 0) {
@@ skipping 363 matching lines @@
 
 
 uint32_t MinidumpModuleList::max_modules_ = 1024;
 
 
 MinidumpModuleList::MinidumpModuleList(Minidump* minidump)
     : MinidumpStream(minidump),
       range_map_(new RangeMap<uint64_t, unsigned int>()),
       modules_(NULL),
       module_count_(0) {
+  range_map_->SetEnableShrinkDown(minidump_->IsAndroid());
 }
 
 
 MinidumpModuleList::~MinidumpModuleList() {
   delete range_map_;
   delete modules_;
 }
 
 
 bool MinidumpModuleList::Read(uint32_t expected_size) {
@@ skipping 192 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, 
+  if (!range_map_->RetrieveRangeAtIndex(sequence, &module_index,
                                         NULL /* base */, NULL /* delta */,
                                         NULL /* size */)) {
     BPLOG(ERROR) << "MinidumpModuleList has no module at sequence " << sequence;
     return NULL;
   }
 
   return GetModuleAtIndex(module_index);
 }
 
 
@@ skipping 11 matching lines @@
   }
 
   return &(*modules_)[index];
 }
 
 
 const CodeModules* MinidumpModuleList::Copy() const {
   return new BasicCodeModules(this);
 }
 
+vector<linked_ptr<const CodeModule> >
+MinidumpModuleList::GetShrunkRangeModules() const {
+  return vector<linked_ptr<const CodeModule> >();
+}
+
+bool MinidumpModuleList::IsModuleShrinkEnabled() const {
+  return range_map_->IsShrinkDownEnabled();
+}
 
 void MinidumpModuleList::Print() {
   if (!valid_) {
     BPLOG(ERROR) << "MinidumpModuleList cannot print invalid data";
     return;
   }
 
   printf("MinidumpModuleList\n");
   printf("  module_count = %d\n", module_count_);
   printf("\n");
@@ skipping 1771 matching lines @@
 MinidumpMemoryInfoList* Minidump::GetMemoryInfoList() {
   MinidumpMemoryInfoList* memory_info_list;
   return GetStream(&memory_info_list);
 }
 
 MinidumpLinuxMapsList *Minidump::GetLinuxMapsList() {
   MinidumpLinuxMapsList *linux_maps_list;
   return GetStream(&linux_maps_list);
 }
 
+bool Minidump::IsAndroid() {
+  // Save the current stream position
+  off_t saved_position = Tell();
+  if (saved_position == -1) {
+    return false;
+  }
+  const MDRawSystemInfo* system_info =
+    GetSystemInfo() ? GetSystemInfo()->system_info() : NULL;
+
+  // Restore position and return
+  if (!SeekSet(saved_position)) {
+    BPLOG(ERROR) << "Couldn't seek back to saved position";
+    return false;
+  }
+
+  return system_info && system_info->platform_id == MD_OS_ANDROID;
+}
+
 static const char* get_stream_name(uint32_t stream_type) {
   switch (stream_type) {
   case MD_UNUSED_STREAM:
     return "MD_UNUSED_STREAM";
   case MD_RESERVED_STREAM_0:
     return "MD_RESERVED_STREAM_0";
   case MD_RESERVED_STREAM_1:
     return "MD_RESERVED_STREAM_1";
   case MD_THREAD_LIST_STREAM:
     return "MD_THREAD_LIST_STREAM";
@@ skipping 93 matching lines @@
            directory_entry->location.data_size);
     printf("  location.rva       = 0x%x\n", directory_entry->location.rva);
     printf("\n");
   }
 
   printf("Streams:\n");
   for (MinidumpStreamMap::const_iterator iterator = stream_map_->begin();
        iterator != stream_map_->end();
        ++iterator) {
     uint32_t stream_type = iterator->first;
-    MinidumpStreamInfo info = iterator->second;
+    const MinidumpStreamInfo& info = iterator->second;
     printf("  stream type 0x%x (%s) at index %d\n", stream_type,
            get_stream_name(stream_type),
            info.stream_index);
   }
   printf("\n");
 }
 
 
 const MDRawDirectory* Minidump::GetDirectoryEntryAtIndex(unsigned int index)
       const {
@@ skipping 136 matching lines @@
     return false;
   }
 
   MinidumpStreamMap::const_iterator iterator = stream_map_->find(stream_type);
   if (iterator == stream_map_->end()) {
     // This stream type didn't exist in the directory.
     BPLOG(INFO) << "SeekToStreamType: type " << stream_type << " not present";
     return false;
   }
 
-  MinidumpStreamInfo info = iterator->second;
+  const MinidumpStreamInfo& info = iterator->second;
   if (info.stream_index >= header_.stream_count) {
     BPLOG(ERROR) << "SeekToStreamType: type " << stream_type <<
                     " out of range: " <<
                     info.stream_index << "/" << header_.stream_count;
     return false;
   }
 
   MDRawDirectory* directory_entry = &(*directory_)[info.stream_index];
   if (!SeekSet(directory_entry->location.rva)) {
     BPLOG(ERROR) << "SeekToStreamType could not seek to stream type " <<
@@ skipping 54 matching lines @@
     return NULL;
   }
 
   *stream = new_stream.release();
   info->stream = *stream;
   return *stream;
 }
 
 
 }  // namespace google_breakpad