Server-side workaround to handle overlapping modules.

src/processor/minidump.cc

Index: src/processor/minidump.cc
diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc
index 81c3d11a36e4a3aed11a6ebde8c66e393a00116b..6d0722185767f574ead911d5ff68349940e548c6 100644
--- a/src/processor/minidump.cc
+++ b/src/processor/minidump.cc
@@ -2109,11 +2109,21 @@ string MinidumpModule::version() const {
 }
 
 
-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";
@@ -2497,6 +2507,7 @@ MinidumpModuleList::MinidumpModuleList(Minidump* minidump)
       range_map_(new RangeMap<uint64_t, unsigned int>()),
       modules_(NULL),
       module_count_(0) {
+  range_map_->SetEnableShrinkDown(true);

[Mark Mentovai, 2016/06/13 14:38:10]

I thought that we were only going to do this for the Android release that needs
it.

[ivanpe, 2016/06/13 21:36:00]

I thought about this.  I'm sorry I didn't mentioned it in the description.  I
believe that it doesn't matter much whether this is enabled for all platforms or
just for Android.  And I actually see some benefits if this is enabled for all
platforms so I'd like to enable it for all platforms if permitted.

First of all, it is not expected to have overlapping modules on any platform, so
such issues indicate either some sort of a corruption or the presence of the
Android hack.

I decided to enable this for all platforms and examine the results.  I thought
I'll only see Android minidumps with this issue, but interestingly enough I also
saw 10s of Windows minidumps as well (out of 10s of millions - so it's a one in
a million kind of thing).

The good thing is that I found this very useful for non-Android platforms as
well.

Here are the benefits if this is enabled for all platforms:
 (1) Reports with a few corrupt module entries will get better stack traces.
 (2) Reports with a few corrupt module entries will have a list of modules.
 (3) It is much easier to spot and blame a corrupt minidump when there are
processing and/or symbolization issues due to conflicting modules.

Here is an example of a crash report: go/crash/7c7d497a00000000.  At the end of
the list of modules ('Modules' tab) you can see a modules with empty name, and
empty debug id that spans a large part of the virtual address space.  Due to
this single corruption, we cannot produce a stack trace.  However with the fix
we can produce a perfect stack trace and also we get an indication that there
were some module conflicts and how the processor dealt with them (shrunk the
address space of the offending module).

Here is what we get without the fix.  Unreadable stack trace and !!! NO list of
modules at all !!!

 0  0x6bc51595
    eip = 0x6bc51595   esp = 0x054df470   ebp = 0x054df484   ebx = 0x0fd0d2a8
    esi = 0x054df498   edi = 0x10037a0c   eax = 0x00000001   ecx = 0x054df498
    edx = 0xfffdf88d   efl = 0x00010286
    Found by: given as instruction pointer in context
 1  0x6caf80f8
    eip = 0x6caf80f8   esp = 0x054df48c   ebp = 0x054df4a0
    Found by: previous frame's frame pointer
 2  0x6bf7dfbc
    eip = 0x6bf7dfbc   esp = 0x054df4a8   ebp = 0x054df4ac
    Found by: previous frame's frame pointer
 3  0x6bff020f
    eip = 0x6bff020f   esp = 0x054df4b4   ebp = 0x054df4d0
    Found by: previous frame's frame pointer
 4  0x6bdbf737
    eip = 0x6bdbf737   esp = 0x054df4d8   ebp = 0x054df50c
    Found by: previous frame's frame pointer
 5  0x6bdbf53c
    eip = 0x6bdbf53c   esp = 0x054df514   ebp = 0x054df51c
    Found by: previous frame's frame pointer
 6  0x6bdbf421
    eip = 0x6bdbf421   esp = 0x054df524   ebp = 0x054df59c
    Found by: previous frame's frame pointer
 7  0x6bdb34ab
    eip = 0x6bdb34ab   esp = 0x054df5a4   ebp = 0x054df5b4
    Found by: previous frame's frame pointer
 8  0x6bdb344d
    eip = 0x6bdb344d   esp = 0x054df5bc   ebp = 0x054df5cc
    Found by: previous frame's frame pointer
 9  0x6bca064d
    eip = 0x6bca064d   esp = 0x054df5d4   ebp = 0x054df630
    Found by: previous frame's frame pointer
10  0x6bca0410
    eip = 0x6bca0410   esp = 0x054df638   ebp = 0x054df8ac
    Found by: previous frame's frame pointer
11  0x6bc9fd95
    eip = 0x6bc9fd95   esp = 0x054df8b4   ebp = 0x054df9b8
    Found by: previous frame's frame pointer
12  0x6bc9f961
    eip = 0x6bc9f961   esp = 0x054df9c0   ebp = 0x054df9d0
    Found by: previous frame's frame pointer
13  0x6bc9f8c8
    eip = 0x6bc9f8c8   esp = 0x054df9d8   ebp = 0x054df9ec
    Found by: previous frame's frame pointer
14  0x6bc9f70d
    eip = 0x6bc9f70d   esp = 0x054df9f4   ebp = 0x054dfa18
    Found by: previous frame's frame pointer
15  0x6bc9f601
    eip = 0x6bc9f601   esp = 0x054dfa20   ebp = 0x054dfa44
    Found by: previous frame's frame pointer
16  0x6bd7844c
    eip = 0x6bd7844c   esp = 0x054dfa4c   ebp = 0x054dfb14
    Found by: previous frame's frame pointer
17  0x6bd48906
    eip = 0x6bd48906   esp = 0x054dfb1c   ebp = 0x054dfb2c
    Found by: previous frame's frame pointer
18  0x6bc9e0a8
    eip = 0x6bc9e0a8   esp = 0x054dfb34   ebp = 0x054dfb68
    Found by: previous frame's frame pointer
19  0x6bc9ddf3
    eip = 0x6bc9ddf3   esp = 0x054dfb70   ebp = 0x054dfb8c
    Found by: previous frame's frame pointer
20  0x75727c04
    eip = 0x75727c04   esp = 0x054dfb94   ebp = 0x054dfba0
    Found by: previous frame's frame pointer
21  0x7762ab8f
    eip = 0x7762ab8f   esp = 0x054dfba8   ebp = 0x054dfbe8
    Found by: previous frame's frame pointer
22  0x7762ab5a
    eip = 0x7762ab5a   esp = 0x054dfbf0   ebp = 0x054dfbf8
    Found by: previous frame's frame pointer


Here is what we get with the fix.  Perfect stack trace and a complete list of
modules (minidump_stackwalk hasn't been updated to show the module conflicts
yet, but the data is readily available in the ProcessState):

Stack trace:
--------------
(chrome.dll -http_stream_parser.cc:392 )
base::internal::InvokeHelper<1,void,base::internal::RunnableAdapter<void (
net::MDnsConnection::*)(int)> >::MakeItSo<base::WeakPtr<net::MDnsConnection>,int
const &>(base::internal::RunnableAdapter<void (
net::MDnsConnection::*)(int)>,base::WeakPtr<net::MDnsConnection>,int const &)
base::internal::Invoker<base::IndexSequence<0>,base::internal::BindState<base::internal::RunnableAdapter<void
(
content::ServiceWorkerFetchDispatcher::*)(content::ServiceWorkerStatusCode)>,void
,base::WeakPtr<content::ServiceWorkerFetchDispatcher>
>,base::internal::InvokeHelper<1,void,base::internal::RunnableAdapter<void (
content::ServiceWorkerFetchDispatcher::*)(content::ServiceWorkerStatusCode)>
>,void >::Run(base::internal::BindStateBase *,content::ServiceWorkerStatusCode
&&)
net::TCPClientSocket::DidCompleteReadWrite(base::Callback<void ,1> const &,int)
base::internal::Invoker<base::IndexSequence<0,1>,base::internal::BindState<base::internal::RunnableAdapter<void
( net::SOCKSClientSocket::*)(base::Callback<void ,1> const &,int)>,void
,base::internal::UnretainedWrapper<net::SOCKSClientSocket>,base::Callback<void
,1> const
&>,base::internal::InvokeHelper<0,void,base::internal::RunnableAdapter<void (
net::SOCKSClientSocket::*)(base::Callback<void ,1> const &,int)> >,void
>::Run(base::internal::BindStateBase *,int &&)
net::TCPSocketWin::DidSignalRead()
net::TCPSocketWin::Core::ReadDelegate::OnObjectSignaled(void *)
base::win::ObjectWatcher::Signal(base::win::ObjectWatcher::Delegate *)
base::internal::Invoker<base::IndexSequence<0,1>,base::internal::BindState<base::internal::RunnableAdapter<void
( base::win::ObjectWatcher::*)(base::win::ObjectWatcher::Delegate *)>,void
,base::WeakPtr<base::win::ObjectWatcher>,base::win::ObjectWatcher::Delegate *
&>,base::internal::InvokeHelper<1,void,base::internal::RunnableAdapter<void (
base::win::ObjectWatcher::*)(base::win::ObjectWatcher::Delegate *)> >,void
>::Run(base::internal::BindStateBase *)
base::debug::TaskAnnotator::RunTask(char const *,base::PendingTask const &)
base::MessageLoop::RunTask(base::PendingTask const &)
base::MessageLoop::DoWork()
base::MessagePumpForIO::DoRunLoop()
base::MessagePumpWin::Run(base::MessagePump::Delegate *)
base::RunLoop::Run()
base::Thread::Run(base::MessageLoop *)
content::BrowserThreadImpl::IOThreadRun(base::MessageLoop *)
content::BrowserThreadImpl::Run(base::MessageLoop *)
base::Thread::ThreadMain()
base::`anonymous namespace'::ThreadFunc
BaseThreadInitThunk
__RtlUserThreadStart
_RtlUserThreadStart


Loaded modules:
--------------------
0x011d0000 - 0x012bbfff  chrome.exe  51.0.2704.84  (main)
0x667e0000 - 0x66948fff  DUI70.dll  6.3.9600.17415
0x6a2f0000 - 0x6a2fafff  msdmo.dll  6.6.9600.17415
...
...
0x775d0000 - 0x7773efff  ntdll.dll  6.3.9600.18233
0x4d8b52a8 - 0xec7552a5    0.0.0.0

 }
 
 
@@ -2709,7 +2720,7 @@ const MinidumpModule* MinidumpModuleList::GetModuleAtSequence(
   }
 
   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;
@@ -2741,6 +2752,10 @@ const CodeModules* MinidumpModuleList::Copy() const {
   return new BasicCodeModules(this);
 }
 
+vector<linked_ptr<const CodeModule> >
+MinidumpModuleList::GetShrunkRangeModules() const {
+  return vector<linked_ptr<const CodeModule> >();
+}
 
 void MinidumpModuleList::Print() {
   if (!valid_) {