Server-side workaround to handle overlapping modules.

src/google_breakpad/processor/minidump.h

 // 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 133 matching lines @@
 
  private:
   // Populate (and validate) the MinidumpStream.  minidump_ is expected
   // to be positioned at the beginning of the stream, so that the next
   // read from the minidump will be at the beginning of the stream.
   // expected_size should be set to the stream's length as contained in
   // the MDRawDirectory record or other identifying record.  A class
   // that implements MinidumpStream can compare expected_size to a
   // known size as an integrity check.
   virtual bool Read(uint32_t expected_size) = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpStream);
 };
 
 
 // MinidumpContext carries a CPU-specific MDRawContext structure, which
 // contains CPU context such as register states.  Each thread has its
 // own context, and the exception record, if present, also has its own
 // context.  Note that if the exception record is present, the context it
 // refers to is probably what the user wants to use for the exception
 // thread, instead of that thread's own context.  The exception thread's
 // context (as opposed to the exception record's context) will contain
@@ skipping 20 matching lines @@
   // not contain a system info stream.
   bool CheckAgainstSystemInfo(uint32_t context_cpu_type);
 
   // Refers to the Minidump object that is the ultimate parent of this
   // Some MinidumpObjects are owned by other MinidumpObjects, but at the
   // root of the ownership tree is always a Minidump.  The Minidump object
   // is kept here for access to its seeking and reading facilities, and
   // for access to data about the minidump file itself, such as whether
   // it should be byte-swapped.
   Minidump* minidump_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpContext);
 };
 
 
 // MinidumpMemoryRegion does not wrap any MDRaw structure, and only contains
 // a reference to an MDMemoryDescriptor.  This object is intended to wrap
 // portions of a minidump file that contain memory dumps.  In normal
 // minidumps, each MinidumpThread owns a MinidumpMemoryRegion corresponding
 // to the thread's stack memory.  MinidumpMemoryList also gives access to
 // memory regions in its list as MinidumpMemoryRegions.  This class
 // adheres to MemoryRegion so that it may be used as a data provider to
@@ skipping 147 matching lines @@
   // The largest number of threads that will be read from a minidump.  The
   // default is 256.
   static uint32_t max_threads_;
 
   // Access to threads using the thread ID as the key.
   IDToThreadMap    id_to_thread_map_;
 
   // The list of threads.
   MinidumpThreads* threads_;
   uint32_t        thread_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpThreadList);
 };
 
 
 // MinidumpModule wraps MDRawModule, which contains information about loaded
 // code modules.  Access is provided to various data referenced indirectly
 // by MDRawModule, such as the module's name and a specification for where
 // to locate debugging information for the module.
 class MinidumpModule : public MinidumpObject,
                        public CodeModule {
  public:
@@ skipping 14 matching lines @@
   // CodeModule implementation
   virtual uint64_t base_address() const {
     return valid_ ? module_.base_of_image : static_cast<uint64_t>(-1);
   }
   virtual uint64_t size() const { return valid_ ? module_.size_of_image : 0; }
   virtual string code_file() const;
   virtual string code_identifier() const;
   virtual string debug_file() const;
   virtual string debug_identifier() const;
   virtual string version() const;
-  virtual const CodeModule* Copy() const;
+  virtual CodeModule* Copy() const;
+
+  // Getter and setter for shrink_down_delta.  This is used when the address
+  // range for a module is shrunk down due to address range conflicts with
+  // other modules.  The base_address and size fields are not updated and they
+  // should always reflect the original values (reported in the minidump).
+  virtual uint64_t shrink_down_delta() const;
+  virtual void SetShrinkDownDelta(uint64_t shrink_down_delta);
 
   // The CodeView record, which contains information to locate the module's
   // debugging information (pdb).  This is returned as uint8_t* because
   // the data can be of types MDCVInfoPDB20* or MDCVInfoPDB70*, or it may be
   // of a type unknown to Breakpad, in which case the raw data will still be
   // returned but no byte-swapping will have been performed.  Check the
   // record's signature in the first four bytes to differentiate between
   // the various types.  Current toolchains generate modules which carry
   // MDCVInfoPDB70 by default.  Returns a pointer to the CodeView record on
   // success, and NULL on failure.  On success, the optional |size| argument
@@ skipping 88 matching lines @@
   virtual unsigned int module_count() const {
     return valid_ ? module_count_ : 0;
   }
   virtual const MinidumpModule* GetModuleForAddress(uint64_t address) const;
   virtual const MinidumpModule* GetMainModule() const;
   virtual const MinidumpModule* GetModuleAtSequence(
       unsigned int sequence) const;
   virtual const MinidumpModule* GetModuleAtIndex(unsigned int index) const;
   virtual const CodeModules* Copy() const;
 
+  // Returns a vector of all modules which address ranges needed to be shrunk
+  // down due to address range conflicts with other modules.
+  virtual vector<linked_ptr<const CodeModule> > GetShrunkRangeModules() const;
+
+  // Returns true, if module address range shrink is enabled.
+  virtual bool IsModuleShrinkEnabled() const;
+
   // Print a human-readable representation of the object to stdout.
   void Print();
 
  protected:
   explicit MinidumpModuleList(Minidump* minidump);
 
  private:
   friend class Minidump;
 
   typedef vector<MinidumpModule> MinidumpModules;
 
   static const uint32_t kStreamType = MD_MODULE_LIST_STREAM;
 
   bool Read(uint32_t expected_size);
 
   // The largest number of modules that will be read from a minidump.  The
   // default is 1024.
   static uint32_t max_modules_;
 
   // Access to modules using addresses as the key.
   RangeMap<uint64_t, unsigned int> *range_map_;
 
   MinidumpModules *modules_;
   uint32_t module_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpModuleList);
 };
 
 
 // MinidumpMemoryList corresponds to a minidump's MEMORY_LIST_STREAM stream,
 // which references the snapshots of all of the memory regions contained
 // within the minidump.  For a normal minidump, this includes stack memory
 // (also referenced by each MinidumpThread, in fact, the MDMemoryDescriptors
 // here and in MDRawThread both point to exactly the same data in a
 // minidump file, conserving space), as well as a 256-byte snapshot of memory
 // surrounding the instruction pointer in the case of an exception.  Other
@@ skipping 42 matching lines @@
 
   // The list of descriptors.  This is maintained separately from the list
   // of regions, because MemoryRegion doesn't own its MemoryDescriptor, it
   // maintains a pointer to it.  descriptors_ provides the storage for this
   // purpose.
   MemoryDescriptors *descriptors_;
 
   // The list of regions.
   MemoryRegions *regions_;
   uint32_t region_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpMemoryList);
 };
 
 
 // MinidumpException wraps MDRawExceptionStream, which contains information
 // about the exception that caused the minidump to be generated, if the
 // minidump was generated in an exception handler called as a result of an
 // exception.  It also provides access to a MinidumpContext object, which
 // contains the CPU context for the exception thread at the time the exception
 // occurred.
 class MinidumpException : public MinidumpStream {
@@ skipping 19 matching lines @@
   friend class Minidump;
 
   static const uint32_t kStreamType = MD_EXCEPTION_STREAM;
 
   explicit MinidumpException(Minidump* minidump);
 
   bool Read(uint32_t expected_size);
 
   MDRawExceptionStream exception_;
   MinidumpContext*     context_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpException);
 };
 
 // MinidumpAssertion wraps MDRawAssertionInfo, which contains information
 // about an assertion that caused the minidump to be generated.
 class MinidumpAssertion : public MinidumpStream {
  public:
   virtual ~MinidumpAssertion();
 
   const MDRawAssertionInfo* assertion() const {
     return valid_ ? &assertion_ : NULL;
@@ skipping 20 matching lines @@
   static const uint32_t kStreamType = MD_ASSERTION_INFO_STREAM;
 
   explicit MinidumpAssertion(Minidump* minidump);
 
   bool Read(uint32_t expected_size);
 
   MDRawAssertionInfo assertion_;
   string expression_;
   string function_;
   string file_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpAssertion);
 };
 
 
 // MinidumpSystemInfo wraps MDRawSystemInfo and provides information about
 // the system on which the minidump was generated.  See also MinidumpMiscInfo.
 class MinidumpSystemInfo : public MinidumpStream {
  public:
   virtual ~MinidumpSystemInfo();
 
   const MDRawSystemInfo* system_info() const {
@@ skipping 33 matching lines @@
 
  private:
   friend class Minidump;
 
   static const uint32_t kStreamType = MD_SYSTEM_INFO_STREAM;
 
   bool Read(uint32_t expected_size);
 
   // A string identifying the CPU vendor, if known.
   const string* cpu_vendor_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpSystemInfo);
 };
 
 
 // MinidumpMiscInfo wraps MDRawMiscInfo and provides information about
 // the process that generated the minidump, and optionally additional system
 // information.  See also MinidumpSystemInfo.
 class MinidumpMiscInfo : public MinidumpStream {
  public:
   const MDRawMiscInfo* misc_info() const {
     return valid_ ? &misc_info_ : NULL;
@@ skipping 13 matching lines @@
   bool Read(uint32_t expected_size_);
 
   MDRawMiscInfo misc_info_;
 
   // Populated by Read.  Contains the converted strings from the corresponding
   // UTF-16 fields in misc_info_
   string standard_name_;
   string daylight_name_;
   string build_string_;
   string dbg_bld_str_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpMiscInfo);
 };
 
 
 // MinidumpBreakpadInfo wraps MDRawBreakpadInfo, which is an optional stream in
 // a minidump that provides additional information about the process state
 // at the time the minidump was generated.
 class MinidumpBreakpadInfo : public MinidumpStream {
  public:
   const MDRawBreakpadInfo* breakpad_info() const {
     return valid_ ? &breakpad_info_ : NULL;
@@ skipping 12 matching lines @@
  private:
   friend class Minidump;
 
   static const uint32_t kStreamType = MD_BREAKPAD_INFO_STREAM;
 
   explicit MinidumpBreakpadInfo(Minidump* minidump_);
 
   bool Read(uint32_t expected_size_);
 
   MDRawBreakpadInfo breakpad_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpBreakpadInfo);
 };
 
 // MinidumpMemoryInfo wraps MDRawMemoryInfo, which provides information
 // about mapped memory regions in a process, including their ranges
 // and protection.
 class MinidumpMemoryInfo : public MinidumpObject {
  public:
   const MDRawMemoryInfo* info() const { return valid_ ? &memory_info_ : NULL; }
 
   // The address of the base of the memory region.
@@ skipping 50 matching lines @@
 
   explicit MinidumpMemoryInfoList(Minidump* minidump_);
 
   bool Read(uint32_t expected_size);
 
   // Access to memory info using addresses as the key.
   RangeMap<uint64_t, unsigned int> *range_map_;
 
   MinidumpMemoryInfos* infos_;
   uint32_t info_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpMemoryInfoList);
 };
 
 // MinidumpLinuxMaps wraps information about a single mapped memory region
 // from /proc/self/maps.
 class MinidumpLinuxMaps : public MinidumpObject {
  public:
   // The memory address of the base of the mapped region.
   uint64_t GetBase() const { return valid_ ? region_.start : 0; }
   // The size of the mapped region.
   uint64_t GetSize() const { return valid_ ? region_.end - region_.start : 0; }
@@ skipping 187 matching lines @@
   // possibility, and consider using GetDirectoryEntryAtIndex (possibly
   // with GetDirectoryEntryCount) if expecting multiple streams of the same
   // type in a single minidump file.
   bool SeekToStreamType(uint32_t stream_type, uint32_t* stream_length);
 
   bool swap() const { return valid_ ? swap_ : false; }
 
   // Print a human-readable representation of the object to stdout.
   void Print();
 
+  // Is the OS Android.
+  bool IsAndroid();
+
  private:
   // MinidumpStreamInfo is used in the MinidumpStreamMap.  It lets
   // the Minidump object locate interesting streams quickly, and
   // provides a convenient place to stash MinidumpStream objects.
   struct MinidumpStreamInfo {
     MinidumpStreamInfo() : stream_index(0), stream(NULL) {}
     ~MinidumpStreamInfo() { delete stream; }
 
     // Index into the MinidumpDirectoryEntries vector
     unsigned int    stream_index;
 
     // Pointer to the stream if cached, or NULL if not yet populated
     MinidumpStream* stream;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(MinidumpStreamInfo);
   };
 
   typedef vector<MDRawDirectory> MinidumpDirectoryEntries;
   typedef map<uint32_t, MinidumpStreamInfo> MinidumpStreamMap;
 
   template<typename T> T* GetStream(T** stream);
 
   // Opens the minidump file, or if already open, seeks to the beginning.
   bool Open();
 
@@ skipping 27 matching lines @@
   // swap_ is true if the minidump file should be byte-swapped.  If the
   // minidump was produced by a CPU that is other-endian than the CPU
   // processing the minidump, this will be true.  If the two CPUs are
   // same-endian, this will be false.
   bool                      swap_;
 
   // Validity of the Minidump structure, false immediately after
   // construction or after a failed Read(); true following a successful
   // Read().
   bool                      valid_;
+
+  DISALLOW_COPY_AND_ASSIGN(Minidump);
 };
 
 
 }  // namespace google_breakpad
 
 
 #endif  // GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__