Annotate FastMalloc functions with returns_nonnull attribute.
[WebKit-https.git] / Source / WTF / wtf / FastMalloc.h
1 /*
2  *  Copyright (C) 2005-2009, 2015-2016 Apple Inc. All rights reserved.
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Library General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Library General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Library General Public License
15  *  along with this library; see the file COPYING.LIB.  If not, write to
16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  *  Boston, MA 02110-1301, USA.
18  *
19  */
20
21 #ifndef WTF_FastMalloc_h
22 #define WTF_FastMalloc_h
23
24 #include <new>
25 #include <stdlib.h>
26 #include <wtf/StdLibExtras.h>
27
28 namespace WTF {
29
30 #if !defined(NDEBUG)
31 WTF_EXPORT_PRIVATE void fastSetMaxSingleAllocationSize(size_t);
32 #endif
33
34 class TryMallocReturnValue {
35 public:
36     TryMallocReturnValue(void*);
37     TryMallocReturnValue(TryMallocReturnValue&&);
38     ~TryMallocReturnValue();
39     template<typename T> bool getValue(T*&) WARN_UNUSED_RETURN;
40 private:
41     void operator=(TryMallocReturnValue&&) = delete;
42     mutable void* m_data;
43 };
44
45 WTF_EXPORT_PRIVATE bool isFastMallocEnabled();
46
47 // These functions call CRASH() if an allocation fails.
48 WTF_EXPORT_PRIVATE void* fastMalloc(size_t) RETURNS_NONNULL;
49 WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t) RETURNS_NONNULL;
50 WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize) RETURNS_NONNULL;
51 WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t) RETURNS_NONNULL;
52 WTF_EXPORT_PRIVATE char* fastStrDup(const char*) RETURNS_NONNULL;
53
54 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t);
55 TryMallocReturnValue tryFastZeroedMalloc(size_t);
56 WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t numElements, size_t elementSize);
57
58 WTF_EXPORT_PRIVATE void fastFree(void*);
59
60 // Allocations from fastAlignedMalloc() must be freed using fastAlignedFree().
61 WTF_EXPORT_PRIVATE void* fastAlignedMalloc(size_t alignment, size_t) RETURNS_NONNULL;
62 WTF_EXPORT_PRIVATE void* tryFastAlignedMalloc(size_t alignment, size_t);
63 WTF_EXPORT_PRIVATE void fastAlignedFree(void*);
64
65 WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
66
67 // FIXME: This is non-helpful; fastMallocGoodSize will be removed soon.
68 WTF_EXPORT_PRIVATE size_t fastMallocGoodSize(size_t);
69
70 WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
71 WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemoryForThisThread();
72
73 struct FastMallocStatistics {
74     size_t reservedVMBytes;
75     size_t committedVMBytes;
76     size_t freeListBytes;
77 };
78 WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
79
80 // This defines a type which holds an unsigned integer and is the same
81 // size as the minimally aligned memory allocation.
82 typedef unsigned long long AllocAlignmentInteger;
83
84 inline TryMallocReturnValue::TryMallocReturnValue(void* data)
85     : m_data(data)
86 {
87 }
88
89 inline TryMallocReturnValue::TryMallocReturnValue(TryMallocReturnValue&& source)
90     : m_data(source.m_data)
91 {
92     source.m_data = nullptr;
93 }
94
95 inline TryMallocReturnValue::~TryMallocReturnValue()
96 {
97     ASSERT(!m_data);
98 }
99
100 template<typename T> inline bool TryMallocReturnValue::getValue(T*& data)
101 {
102     data = static_cast<T*>(m_data);
103     m_data = nullptr;
104     return data;
105 }
106
107 } // namespace WTF
108
109 #if !defined(NDEBUG)
110 using WTF::fastSetMaxSingleAllocationSize;
111 #endif
112
113 using WTF::isFastMallocEnabled;
114 using WTF::fastCalloc;
115 using WTF::fastFree;
116 using WTF::fastMalloc;
117 using WTF::fastMallocGoodSize;
118 using WTF::fastMallocSize;
119 using WTF::fastRealloc;
120 using WTF::fastStrDup;
121 using WTF::fastZeroedMalloc;
122 using WTF::tryFastAlignedMalloc;
123 using WTF::tryFastCalloc;
124 using WTF::tryFastMalloc;
125 using WTF::tryFastZeroedMalloc;
126 using WTF::fastAlignedMalloc;
127 using WTF::fastAlignedFree;
128
129 #if COMPILER(GCC_OR_CLANG) && OS(DARWIN)
130 #define WTF_PRIVATE_INLINE __private_extern__ inline __attribute__((always_inline))
131 #elif COMPILER(GCC_OR_CLANG)
132 #define WTF_PRIVATE_INLINE inline __attribute__((always_inline))
133 #elif COMPILER(MSVC)
134 #define WTF_PRIVATE_INLINE __forceinline
135 #else
136 #define WTF_PRIVATE_INLINE inline
137 #endif
138
139 #define WTF_MAKE_FAST_ALLOCATED \
140 public: \
141     void* operator new(size_t, void* p) { return p; } \
142     void* operator new[](size_t, void* p) { return p; } \
143     \
144     void* operator new(size_t size) \
145     { \
146         return ::WTF::fastMalloc(size); \
147     } \
148     \
149     void operator delete(void* p) \
150     { \
151         ::WTF::fastFree(p); \
152     } \
153     \
154     void* operator new[](size_t size) \
155     { \
156         return ::WTF::fastMalloc(size); \
157     } \
158     \
159     void operator delete[](void* p) \
160     { \
161         ::WTF::fastFree(p); \
162     } \
163     void* operator new(size_t, NotNullTag, void* location) \
164     { \
165         ASSERT(location); \
166         return location; \
167     } \
168 private: \
169 typedef int __thisIsHereToForceASemicolonAfterThisMacro
170
171 #endif /* WTF_FastMalloc_h */