Upgrade AlignedMemory to support dynamic allocations.

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 is a POD type that gives you a portable way to specify static
 // or local stack data of a given alignment and size. 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<sizeof(MyClass), ALIGNOF(MyClass)> my_class;
+//   static AlignedMemory<ALIGNOF(MyClass), sizeof(MyClass)> my_class;
 //
 //   // ... at runtime:
 //   new(my_class.void_data()) MyClass();
 //
 //   // ... use it:
 //   MyClass* mc = my_class.data_as<MyClass>();
 //
 //   // ... later, to destruct my_class:
 //   my_class.data_as<MyClass>()->MyClass::~MyClass();
+//
+// Alternatively, a runtime sized AlignedMemory instance can be created:
+//
+//   AlignedMemory<|alignment|> my_memory(|size|);
+//
+//   // ... use it:
+//   float* float_array = my_memory.data_as<float>();
+//
+// Memory will be freed when AlignedMemory is destructed.
 
 #ifndef BASE_MEMORY_ALIGNED_MEMORY_H_
 #define BASE_MEMORY_ALIGNED_MEMORY_H_
 
+#if !defined(_XOPEN_SOURCE) || (_XOPEN_SOURCE < 600)
+#define _XOPEN_SOURCE 600  // for posix_memalign
+#endif
+
+#if defined(COMPILER_MSVC) || defined(OS_ANDROID)
+#include <malloc.h>
+#endif
+#include <stdlib.h>
+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 
+#if defined(COMPILER_MSVC)
+#define INTERNAL_ALIGNED_MALLOC(ptr, align, size) \
+    ptr = _aligned_malloc(size, align);

[jbates, 2012/07/19 03:45:37]

typically don't put the semicolon here

[DaleCurtis, 2012/07/20 02:38:56]

Done.

+#define INTERNAL_ALIGNED_FREE(ptr) \
+    _aligned_free(ptr);

[jbates, 2012/07/19 03:45:37]

no semicolon?

[DaleCurtis, 2012/07/20 02:38:56]

Done.

+#else
+#if defined(OS_ANDROID)
+#define INTERNAL_ALIGNED_MALLOC(ptr, align, size) \
+    ptr = memalign(align, size);

[jbates, 2012/07/19 03:45:37]

no semicolon?

[DaleCurtis, 2012/07/20 02:38:56]

Done.

+#else
+// TODO(dalecurtis): Not sure why this is necessary, but without it none of the
+// Buildbots can find the posix_memalign definition.  Everything builds fine
+// locally with or without it.
+extern int posix_memalign(void **ptr, size_t align, size_t size);
+#define INTERNAL_ALIGNED_MALLOC(ptr, align, size) \

[jbates, 2012/07/19 03:45:37]

just to be pedantic in case someone uses this in an if statement, how about a
do/while(0) here:
do { \
 ...
} while(0)

[DaleCurtis, 2012/07/20 02:38:56]

Done.

+    if (posix_memalign(&ptr, align, size)) \
+      ptr = NULL;
+#endif
+#define INTERNAL_ALIGNED_FREE(ptr) \
+    free(ptr);

[jbates, 2012/07/19 03:45:37]

no semicolon?

[DaleCurtis, 2012/07/20 02:38:56]

Done.

+#endif
+
 namespace base {
 
 // AlignedMemory 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>
+template <size_t ByteAlignment, size_t Size = 0>
 struct AlignedMemory {};
 
 #define BASE_DECL_ALIGNED_MEMORY(byte_alignment) \
     template <size_t Size> \
-    class AlignedMemory<Size, byte_alignment> { \
+    class AlignedMemory<byte_alignment, Size> { \
      public: \
-      ALIGNAS(byte_alignment) uint8 data_[Size]; \
       void* void_data() { return reinterpret_cast<void*>(data_); } \
       const void* void_data() const { \
         return reinterpret_cast<const void*>(data_); \
       } \
       template<typename Type> \
       Type* data_as() { return reinterpret_cast<Type*>(void_data()); } \
       template<typename Type> \
       const Type* data_as() const { \
         return reinterpret_cast<const Type*>(void_data()); \
       } \
      private: \
+      ALIGNAS(byte_alignment) uint8 data_[Size]; \
       void* operator new(size_t); \
       void operator delete(void*); \
-    }
+    }; \
+    template <> \
+    class AlignedMemory<byte_alignment, 0> { \
+     public: \
+      explicit AlignedMemory(size_t size) { \
+        DCHECK_GT(size, static_cast<size_t>(0)); \
+        DCHECK_EQ(byte_alignment & (byte_alignment - 1), 0); \

[jbates, 2012/07/19 03:45:37]

is this necessary here since all the alignments are declared below? (dcheck is
pretty heavy weight, so just a compile time/ code bloat concern)

[DaleCurtis, 2012/07/20 02:38:56]

Good point. Removed.

+        DCHECK_EQ(byte_alignment % sizeof(void*), static_cast<size_t>(0)); \

[jbates, 2012/07/19 03:45:37]

would it make sense to just do a MAX(byte_alignment, sizeof(void*)) in places
where it's used? seems less awkward since the 1, 2, and 4 byte alignments are
declared for this template.

[DaleCurtis, 2012/07/20 02:38:56]

I've removed all of this in favor of forcing a NULL dereference on a failed
allocation and selecting which templates to specialize based on 64-bit or
32-bit.

+        INTERNAL_ALIGNED_MALLOC(data_, byte_alignment, size) \
+      } \
+      ~AlignedMemory() { \
+        if (data_) \
+          INTERNAL_ALIGNED_FREE(data_) \
+      } \
+      void* void_data() { return data_; } \
+      const void* void_data() const { \
+        return reinterpret_cast<const void*>(data_); \
+      } \
+      template<typename Type> \
+      Type* data_as() { return reinterpret_cast<Type*>(void_data()); } \
+      template<typename Type> \
+      const Type* data_as() const { \
+        return reinterpret_cast<const Type*>(void_data()); \
+      } \
+     private: \
+      void* data_; \
+      void* operator new(size_t); \
+      void operator delete(void*); \
+    };
 
 // Specialization for all alignments is required because MSVC (as of VS 2008)
 // does not understand ALIGNAS(ALIGNOF(Type)) or ALIGNAS(template_param).
 // Greater than 4096 alignment is not supported by some compilers, so 4096 is
 // the maximum specified here.
-BASE_DECL_ALIGNED_MEMORY(1);
-BASE_DECL_ALIGNED_MEMORY(2);
-BASE_DECL_ALIGNED_MEMORY(4);
-BASE_DECL_ALIGNED_MEMORY(8);
-BASE_DECL_ALIGNED_MEMORY(16);
-BASE_DECL_ALIGNED_MEMORY(32);
-BASE_DECL_ALIGNED_MEMORY(64);
-BASE_DECL_ALIGNED_MEMORY(128);
-BASE_DECL_ALIGNED_MEMORY(256);
-BASE_DECL_ALIGNED_MEMORY(512);
-BASE_DECL_ALIGNED_MEMORY(1024);
-BASE_DECL_ALIGNED_MEMORY(2048);
-BASE_DECL_ALIGNED_MEMORY(4096);
+BASE_DECL_ALIGNED_MEMORY(1)
+BASE_DECL_ALIGNED_MEMORY(2)
+BASE_DECL_ALIGNED_MEMORY(4)
+BASE_DECL_ALIGNED_MEMORY(8)
+BASE_DECL_ALIGNED_MEMORY(16)
+BASE_DECL_ALIGNED_MEMORY(32)
+BASE_DECL_ALIGNED_MEMORY(64)
+BASE_DECL_ALIGNED_MEMORY(128)
+BASE_DECL_ALIGNED_MEMORY(256)
+BASE_DECL_ALIGNED_MEMORY(512)
+BASE_DECL_ALIGNED_MEMORY(1024)
+BASE_DECL_ALIGNED_MEMORY(2048)
+BASE_DECL_ALIGNED_MEMORY(4096)
+
+#undef INTERNAL_ALIGNED_MALLOC
+#undef INTERNAL_ALIGNED_FREE
+#undef BASE_DECL_ALIGNED_MEMORY
 
 }  // base
 
 #endif  // BASE_MEMORY_ALIGNED_MEMORY_H_