security/sandbox/chromium/base/memory/aligned_memory.h@7e26c7da4463
security/sandbox/chromium/base/memory/aligned_memory.h
Wed, 31 Dec 2014 06:55:50 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:55:50 +0100
- changeset 2
- 7e26c7da4463
- permissions
- -rw-r--r--
Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 // AlignedMemory is a POD type that gives you a portable way to specify static
6 // or local stack data of a given alignment and size. For example, if you need
7 // static storage for a class, but you want manual control over when the object
8 // is constructed and destructed (you don't want static initialization and
9 // destruction), use AlignedMemory:
10 //
11 // static AlignedMemory<sizeof(MyClass), ALIGNOF(MyClass)> my_class;
12 //
13 // // ... at runtime:
14 // new(my_class.void_data()) MyClass();
15 //
16 // // ... use it:
17 // MyClass* mc = my_class.data_as<MyClass>();
18 //
19 // // ... later, to destruct my_class:
20 // my_class.data_as<MyClass>()->MyClass::~MyClass();
21 //
22 // Alternatively, a runtime sized aligned allocation can be created:
23 //
24 // float* my_array = static_cast<float*>(AlignedAlloc(size, alignment));
25 //
26 // // ... later, to release the memory:
27 // AlignedFree(my_array);
28 //
29 // Or using scoped_ptr_malloc:
30 //
31 // scoped_ptr_malloc<float, ScopedPtrAlignedFree> my_array(
32 // static_cast<float*>(AlignedAlloc(size, alignment)));
34 #ifndef BASE_MEMORY_ALIGNED_MEMORY_H_
35 #define BASE_MEMORY_ALIGNED_MEMORY_H_
37 #include "base/base_export.h"
38 #include "base/basictypes.h"
39 #include "base/compiler_specific.h"
41 #if defined(COMPILER_MSVC)
42 #include <malloc.h>
43 #else
44 #include <stdlib.h>
45 #endif
47 namespace base {
49 // AlignedMemory is specialized for all supported alignments.
50 // Make sure we get a compiler error if someone uses an unsupported alignment.
51 template <size_t Size, size_t ByteAlignment>
52 struct AlignedMemory {};
54 #define BASE_DECL_ALIGNED_MEMORY(byte_alignment) \
55 template <size_t Size> \
56 class AlignedMemory<Size, byte_alignment> { \
57 public: \
58 ALIGNAS(byte_alignment) uint8 data_[Size]; \
59 void* void_data() { return static_cast<void*>(data_); } \
60 const void* void_data() const { \
61 return static_cast<const void*>(data_); \
62 } \
63 template<typename Type> \
64 Type* data_as() { return static_cast<Type*>(void_data()); } \
65 template<typename Type> \
66 const Type* data_as() const { \
67 return static_cast<const Type*>(void_data()); \
68 } \
69 private: \
70 void* operator new(size_t); \
71 void operator delete(void*); \
72 }
74 // Specialization for all alignments is required because MSVC (as of VS 2008)
75 // does not understand ALIGNAS(ALIGNOF(Type)) or ALIGNAS(template_param).
76 // Greater than 4096 alignment is not supported by some compilers, so 4096 is
77 // the maximum specified here.
78 BASE_DECL_ALIGNED_MEMORY(1);
79 BASE_DECL_ALIGNED_MEMORY(2);
80 BASE_DECL_ALIGNED_MEMORY(4);
81 BASE_DECL_ALIGNED_MEMORY(8);
82 BASE_DECL_ALIGNED_MEMORY(16);
83 BASE_DECL_ALIGNED_MEMORY(32);
84 BASE_DECL_ALIGNED_MEMORY(64);
85 BASE_DECL_ALIGNED_MEMORY(128);
86 BASE_DECL_ALIGNED_MEMORY(256);
87 BASE_DECL_ALIGNED_MEMORY(512);
88 BASE_DECL_ALIGNED_MEMORY(1024);
89 BASE_DECL_ALIGNED_MEMORY(2048);
90 BASE_DECL_ALIGNED_MEMORY(4096);
92 #undef BASE_DECL_ALIGNED_MEMORY
94 BASE_EXPORT void* AlignedAlloc(size_t size, size_t alignment);
96 inline void AlignedFree(void* ptr) {
97 #if defined(COMPILER_MSVC)
98 _aligned_free(ptr);
99 #else
100 free(ptr);
101 #endif
102 }
104 // Helper class for use with scoped_ptr_malloc.
105 class BASE_EXPORT ScopedPtrAlignedFree {
106 public:
107 inline void operator()(void* ptr) const {
108 AlignedFree(ptr);
109 }
110 };
112 } // namespace base
114 #endif // BASE_MEMORY_ALIGNED_MEMORY_H_
