* Added breakpad support for Linux.

thirdparty/breakpad/common/memory.h

@@ -0,0 +1,206 @@
+// 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_BREAKPAD_COMMON_MEMORY_H_
+#define GOOGLE_BREAKPAD_COMMON_MEMORY_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+#ifdef __APPLE__
+#define sys_mmap mmap
+#define sys_mmap2 mmap
+#define sys_munmap munmap
+#define MAP_ANONYMOUS MAP_ANON
+#else
+#include "third_party/lss/linux_syscall_support.h"
+#endif
+
+namespace google_breakpad {
+
+// This is very simple allocator which fetches pages from the kernel directly.
+// 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) {
+  }
+
+  ~PageAllocator() {
+    FreeAll();
+  }
+
+  void *Alloc(unsigned bytes) {
+    if (!bytes)
+      return NULL;
+
+    if (current_page_ && page_size_ - page_offset_ >= bytes) {
+      uint8_t *const ret = current_page_ + page_offset_;
+      page_offset_ += bytes;
+      if (page_offset_ == page_size_) {
+        page_offset_ = 0;
+        current_page_ = NULL;
+      }
+
+      return ret;
+    }
+
+    const unsigned pages =
+        (bytes + sizeof(PageHeader) + page_size_ - 1) / page_size_;
+    uint8_t *const ret = GetNPages(pages);
+    if (!ret)
+      return NULL;
+
+    page_offset_ = (page_size_ - (page_size_ * pages - (bytes + sizeof(PageHeader)))) % page_size_;
+    current_page_ = page_offset_ ? ret + page_size_ * (pages - 1) : NULL;
+
+    return ret + sizeof(PageHeader);
+  }
+
+ private:
+  uint8_t *GetNPages(unsigned num_pages) {
+#ifdef __x86_64
+    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;
+
+    struct PageHeader *header = reinterpret_cast<PageHeader*>(a);
+    header->next = last_;
+    header->num_pages = num_pages;
+    last_ = header;
+
+    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.
+    unsigned num_pages;  // the number of pages in this set.
+  };
+
+  const unsigned page_size_;
+  PageHeader *last_;
+  uint8_t *current_page_;
+  unsigned page_offset_;
+};
+
+// A wasteful vector is like a normal std::vector, except that it's very much
+// simplier and 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:
+  wasteful_vector(PageAllocator *allocator, unsigned size_hint = 16)
+      : allocator_(allocator),
+        a_((T*) allocator->Alloc(sizeof(T) * size_hint)),
+        allocated_(size_hint),
+        used_(0) {
+  }
+
+  void push_back(const T& new_element) {
+    if (used_ == allocated_)
+      Realloc(allocated_ * 2);
+    a_[used_++] = new_element;
+  }
+
+  size_t size() const {
+    return used_;
+  }
+
+  void resize(unsigned sz, T c = T()) {
+    // No need to test "sz >= 0", as "sz" is unsigned.
+    if (sz <= used_) {
+      used_ = sz;
+    } else {
+      unsigned a = allocated_;
+      if (sz > a) {
+        while (sz > a) {
+          a *= 2;
+        }
+        Realloc(a);
+      }
+      while (sz > used_) {
+        a_[used_++] = c;
+      }
+    }
+  }
+
+  T& operator[](size_t index) {
+    return a_[index];
+  }
+
+  const T& operator[](size_t index) const {
+    return a_[index];
+  }
+
+ private:
+  void Realloc(unsigned new_size) {
+    T *new_array =
+        reinterpret_cast<T*>(allocator_->Alloc(sizeof(T) * new_size));
+    memcpy(new_array, a_, used_ * sizeof(T));
+    a_ = new_array;
+    allocated_ = new_size;
+  }
+
+  PageAllocator *const allocator_;
+  T *a_;  // pointer to an array of |allocated_| elements.
+  unsigned allocated_;  // size of |a_|, in elements.
+  unsigned used_;  // number of used slots in |a_|.
+};
+
+}  // namespace google_breakpad
+
+inline void* operator new(size_t nbytes,
+                          google_breakpad::PageAllocator& allocator) {
+   return allocator.Alloc(nbytes);
+}
+
+#endif  // GOOGLE_BREAKPAD_COMMON_MEMORY_H_