Add ALIGNAS and ALIGNOF macros to ensure proper alignment of StaticMemorySingletonTraits

base/memory/aligned_memory.h

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// AlignedMemory and RawAlignedMemory give you portable ways to specify aligned
+// static or local stack data. For example, if you need static storage for a
+// class, but you want manual control over when the object is constructed and
+// destructed (you don't want static initialization and destruction), use
+// AlignedMemory:
+//
+//   static AlignedMemory<MyClass> my_class;
+//
+//   // ... at runtime:
+//   new(my_class.data()) MyClass();
+//
+//   // ... later, to destruct my_class:
+//   my_class.data()->MyClass::~MyClass();
+//
+// RawAlignedMemory just contains a uint8 buffer with a specified size and
+// memory alignment.
+
+
+#ifndef BASE_MEMORY_ALIGNED_MEMORY_H_
+#define BASE_MEMORY_ALIGNED_MEMORY_H_
+#pragma once
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+
+namespace base {
+
+// RawAlignedMemory is specialized for all supported alignments.
+// Make sure we get a compiler error if someone uses an unsupported alignment.
+template <size_t Size, size_t ByteAlignment>
+struct RawAlignedMemory {};
+
+#define BASE_DECL_RAW_ALIGNED_MEMORY(byte_alignment) \
+    template <size_t Size> \
+    class RawAlignedMemory<Size, byte_alignment> { \
+     public: \
+      void* void_data() { return reinterpret_cast<void*>(data_); } \
+     private: \
+      ALIGNAS(byte_alignment) uint8 data_[Size]; \
+      void* operator new(size_t size); \
+      void operator delete(void *ptr); \
+    }
+
+// Specialization for all alignments is required because MSVC (as of VS 2008)
+// does not understand ALIGNAS(ALIGNOF(Type)) or ALIGNAS(template_param).
+BASE_DECL_RAW_ALIGNED_MEMORY(1);
+BASE_DECL_RAW_ALIGNED_MEMORY(2);
+BASE_DECL_RAW_ALIGNED_MEMORY(4);
+BASE_DECL_RAW_ALIGNED_MEMORY(8);
+BASE_DECL_RAW_ALIGNED_MEMORY(16);
+BASE_DECL_RAW_ALIGNED_MEMORY(32);
+BASE_DECL_RAW_ALIGNED_MEMORY(64);
+BASE_DECL_RAW_ALIGNED_MEMORY(128);
+BASE_DECL_RAW_ALIGNED_MEMORY(256);
+BASE_DECL_RAW_ALIGNED_MEMORY(512);
+BASE_DECL_RAW_ALIGNED_MEMORY(1024);
+BASE_DECL_RAW_ALIGNED_MEMORY(2048);
+BASE_DECL_RAW_ALIGNED_MEMORY(4096);
+
+template <typename Type>
+class AlignedMemory : public RawAlignedMemory<sizeof(Type), ALIGNOF(Type)> {
+ public:
+  Type* data() {
+    return reinterpret_cast<Type*>(this->void_data());
+  }
+};
+
+}  // base
+
+#endif  // BASE_MEMORY_ALIGNED_MEMORY_H_