Switch the Linux minidump writer to use MDCVInfoELF for CV data.

src/common/memory.h

 // Copyright (c) 2009, 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 46 matching lines @@
 // Thus, it can be used even when the heap may be corrupted.
 //
 // There is no free operation. The pages are only freed when the object is
 // destroyed.
 class PageAllocator {
  public:
   PageAllocator()
       : page_size_(getpagesize()),
         last_(NULL),
         current_page_(NULL),
-        page_offset_(0) {
+        page_offset_(0),
+        pages_allocated_(0) {
   }
 
   ~PageAllocator() {
     FreeAll();
   }
 
   void *Alloc(size_t bytes) {
     if (!bytes)
       return NULL;
 
@@ skipping 27 matching lines @@
   bool OwnsPointer(const void* p) {
     for (PageHeader* header = last_; header; header = header->next) {
       const char* current = reinterpret_cast<char*>(header);
       if ((p >= current) && (p < current + header->num_pages * page_size_))
         return true;
     }
 
     return false;
   }
 
+  unsigned long pages_allocated() { return pages_allocated_; }
+
  private:
   uint8_t *GetNPages(size_t num_pages) {
 #if defined(__x86_64__) || defined(__aarch64__) || defined(__aarch64__) || \
     ((defined(__mips__) && _MIPS_SIM == _ABI64))
     void *a = sys_mmap(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 #else
     void *a = sys_mmap2(NULL, page_size_ * num_pages, PROT_READ | PROT_WRITE,
                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 #endif
     if (a == MAP_FAILED)
       return NULL;
 
 #if defined(MEMORY_SANITIZER)
     // We need to indicate to MSan that memory allocated through sys_mmap is
     // initialized, since linux_syscall_support.h doesn't have MSan hooks.
     __msan_unpoison(a, page_size_ * num_pages);
 #endif
 
     struct PageHeader *header = reinterpret_cast<PageHeader*>(a);
     header->next = last_;
     header->num_pages = num_pages;
     last_ = header;
 
+    pages_allocated_ += num_pages;
+
     return reinterpret_cast<uint8_t*>(a);
   }
 
   void FreeAll() {
     PageHeader *next;
 
     for (PageHeader *cur = last_; cur; cur = next) {
       next = cur->next;
       sys_munmap(cur, cur->num_pages * page_size_);
     }
   }
 
   struct PageHeader {
     PageHeader *next;  // pointer to the start of the next set of pages.
     size_t num_pages;  // the number of pages in this set.
   };
 
   const size_t page_size_;
   PageHeader *last_;
   uint8_t *current_page_;
   size_t page_offset_;
+  unsigned long pages_allocated_;
 };
 
 // Wrapper to use with STL containers
 template <typename T>
 struct PageStdAllocator : public std::allocator<T> {
   typedef typename std::allocator<T>::pointer pointer;
   typedef typename std::allocator<T>::size_type size_type;
 
-  explicit PageStdAllocator(PageAllocator& allocator): allocator_(allocator) {}
+  explicit PageStdAllocator(PageAllocator& allocator) : allocator_(allocator),
+                                                        stackdata_(NULL),
+                                                        stackdata_size_(0)
+  {}
+
   template <class Other> PageStdAllocator(const PageStdAllocator<Other>& other)
-      : allocator_(other.allocator_) {}
+      : allocator_(other.allocator_),
+        stackdata_(nullptr),
+        stackdata_size_(0)
+  {}
+
+  explicit PageStdAllocator(PageAllocator& allocator,
+                            pointer stackdata,
+                            size_type stackdata_size) : allocator_(allocator),
+      stackdata_(stackdata),
+      stackdata_size_(stackdata_size)
+  {}
 
   inline pointer allocate(size_type n, const void* = 0) {
-    return static_cast<pointer>(allocator_.Alloc(sizeof(T) * n));
+    const size_type size = sizeof(T) * n;
+    if (size <= stackdata_size_) {
+      return stackdata_;
+    }
+    return static_cast<pointer>(allocator_.Alloc(size));
   }
 
   inline void deallocate(pointer, size_type) {
     // The PageAllocator doesn't free.
   }
 
   template <typename U> struct rebind {
     typedef PageStdAllocator<U> other;
   };
 
  private:
   // Silly workaround for the gcc from Android's ndk (gcc 4.6), which will
   // otherwise complain that `other.allocator_` is private in the constructor
   // code.
   template<typename Other> friend struct PageStdAllocator;
 
   PageAllocator& allocator_;
+  pointer stackdata_;
+  size_type stackdata_size_;
 };
 
 // A wasteful vector is a std::vector, except that it allocates memory from a
 // PageAllocator. It's wasteful because, when resizing, it always allocates a
 // whole new array since the PageAllocator doesn't support realloc.
 template<class T>
 class wasteful_vector : public std::vector<T, PageStdAllocator<T> > {
  public:
   wasteful_vector(PageAllocator* allocator, unsigned size_hint = 16)
       : std::vector<T, PageStdAllocator<T> >(PageStdAllocator<T>(*allocator)) {
     std::vector<T, PageStdAllocator<T> >::reserve(size_hint);
   }
+ protected:
+  wasteful_vector(PageStdAllocator<T> allocator)
+      : std::vector<T, PageStdAllocator<T> >(allocator) {}
+};
+
+// auto_wasteful_vector allocates space on the stack for N entries to avoid
+// using the PageAllocator for small data, while still allowing for larger data.
+template<class T, unsigned int N>
+class auto_wasteful_vector : public wasteful_vector<T> {
+ T stackdata_[N];
+ public:
+  auto_wasteful_vector(PageAllocator* allocator)
+      : wasteful_vector<T>(
+            PageStdAllocator<T>(*allocator,
+                                &stackdata_[0],
+                                sizeof(stackdata_))) {
+    std::vector<T, PageStdAllocator<T> >::reserve(N);
+  }
 };
 
 }  // namespace google_breakpad
 
 inline void* operator new(size_t nbytes,
                           google_breakpad::PageAllocator& allocator) {
   return allocator.Alloc(nbytes);
 }
 
 #endif  // GOOGLE_BREAKPAD_COMMON_MEMORY_H_