Add AlignedVector and use it for vector<MEMORY_BASIC_INFORMATION64>

util/stdlib/aligned_allocator.h

Index: util/stdlib/aligned_allocator.h
diff --git a/util/stdlib/aligned_allocator.h b/util/stdlib/aligned_allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..85d264d988e8a19b1911155f8ccbe9ec44c58946
--- /dev/null
+++ b/util/stdlib/aligned_allocator.h
@@ -0,0 +1,130 @@
+// Copyright 2015 The Crashpad Authors. All rights reserved.

[scottmg, 2015/12/04 19:58:51]

I'm surprised we don't have this in base. I guess all the gpu stuff does their
alignment manually or in angle.

+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_
+#define CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_
+
+#include <stddef.h>
+
+#include <limits>
+#include <memory>
+#include <new>
+#include <utility>
+#include <vector>
+
+#include "base/compiler_specific.h"
+#include "build/build_config.h"
+
+#if defined(COMPILER_MSVC) && _MSC_VER < 1900
+#define NOEXCEPT _NOEXCEPT
+#else
+#define NOEXCEPT noexcept
+#endif
+
+namespace crashpad {
+namespace internal {
+
+//! \brief Allocates memory with the specified alignment constraint.
+//!
+//! This function wraps `posix_memalign()` or `_aligned_malloc()`. Memory
+//! allocated by this function must be released by AlignFree().
+void* AlignedAllocate(size_t alignment, size_t size);
+
+//! \brief Frees memory allocated by AlignedAllocate().
+//!
+//! This function wraps `free()` or `_aligned_free()`.
+void AlignedFree(void* pointer);
+
+}  // namespace internal
+
+//! \brief A standard allocator that aligns its allocations as requested,
+//!     suitable for use as an allocator in standard containers.
+//!
+//! This is similar to `std::allocator<T>`, with the addition of an alignment
+//! guarantee. \a Alignment must be a power of 2. If \a Alignment is not
+//! specified, the default alignment for type \a T is used.
+template <class T, size_t Alignment = ALIGNOF(T)>
+struct AlignedAllocator {
+ public:
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  template <class U>
+  struct rebind {
+    using other = AlignedAllocator<U, Alignment>;
+  };
+
+  AlignedAllocator() NOEXCEPT {}
+  AlignedAllocator(const AlignedAllocator& other) NOEXCEPT {}
+
+  template <typename U>
+  AlignedAllocator(const AlignedAllocator<U, Alignment>& other) NOEXCEPT {}
+
+  ~AlignedAllocator() {}
+
+  pointer address(reference x) NOEXCEPT { return &x; }
+  const_pointer address(const_reference x) { return &x; }
+
+  pointer allocate(size_type n, std::allocator<void>::const_pointer hint = 0) {
+    return reinterpret_cast<pointer>(
+        internal::AlignedAllocate(Alignment, sizeof(value_type) * n));
+  }
+
+  void deallocate(pointer p, size_type n) { internal::AlignedFree(p); }
+
+  size_type max_size() const NOEXCEPT {
+    return std::numeric_limits<size_type>::max() / sizeof(value_type);
+  }
+
+  template <class U, class... Args>
+  void construct(U* p, Args&&... args) {
+    new (reinterpret_cast<void*>(p)) U(std::forward<Args>(args)...);
+  }
+
+  template <class U>
+  void destroy(U* p) {
+    p->~U();
+  }
+};
+
+template <class T, class U, size_t Alignment>
+bool operator==(const AlignedAllocator<T, Alignment>& lhs,
+                const AlignedAllocator<U, Alignment>& rhs) {
+  return true;
+}
+
+template <class T, class U, size_t Alignment>
+bool operator!=(const AlignedAllocator<T, Alignment>& lhs,
+                const AlignedAllocator<U, Alignment>& rhs) {
+  return false;
+}
+
+//! \brief A `std::vector` using AlignedAllocator.
+//!
+//! This is similar to `std::vector<T>`, with the addition of an alignment
+//! guarantee. \a Alignment must be a power of 2. If \a Alignment is not
+//! specified, the default alignment for type \a T is used.
+template <typename T, size_t Alignment = ALIGNOF(T)>
+using AlignedVector = std::vector<T, AlignedAllocator<T, Alignment>>;
+
+}  // namespace crashpad
+
+#undef NOEXCEPT
+
+#endif  // CRASHPAD_UTIL_STDLIB_ALIGNED_ALLOCATOR_H_