CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / intern / guardedalloc / intern / mallocn_intern.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2013 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup MEM
22  */
23
24 #ifndef __MALLOCN_INTERN_H__
25 #define __MALLOCN_INTERN_H__
26
27 /* mmap exception */
28 #if defined(WIN32)
29 #  include "mmap_win.h"
30 #else
31 #  include <sys/mman.h>
32 #endif
33
34 #ifdef __GNUC__
35 #  define UNUSED(x) UNUSED_##x __attribute__((__unused__))
36 #else
37 #  define UNUSED(x) UNUSED_##x
38 #endif
39
40 #undef HAVE_MALLOC_STATS
41 #define USE_MALLOC_USABLE_SIZE /* internal, when we have malloc_usable_size() */
42
43 #if defined(__linux__) || (defined(__FreeBSD_kernel__) && !defined(__FreeBSD__)) || \
44     defined(__GLIBC__)
45 #  include <malloc.h>
46 #  define HAVE_MALLOC_STATS
47 #elif defined(__FreeBSD__)
48 #  include <malloc_np.h>
49 #elif defined(__APPLE__)
50 #  include <malloc/malloc.h>
51 #  define malloc_usable_size malloc_size
52 #elif defined(WIN32)
53 #  include <malloc.h>
54 #  define malloc_usable_size _msize
55 #elif defined(__HAIKU__)
56 #  include <malloc.h>
57 size_t malloc_usable_size(void *ptr);
58 #else
59 #  pragma message "We don't know how to use malloc_usable_size on your platform"
60 #  undef USE_MALLOC_USABLE_SIZE
61 #endif
62
63 /* Blame Microsoft for LLP64 and no inttypes.h, quick workaround needed: */
64 #if defined(WIN64)
65 #  define SIZET_FORMAT "%I64u"
66 #  define SIZET_ARG(a) ((unsigned long long)(a))
67 #else
68 #  define SIZET_FORMAT "%lu"
69 #  define SIZET_ARG(a) ((unsigned long)(a))
70 #endif
71
72 #define SIZET_ALIGN_4(len) ((len + 3) & ~(size_t)3)
73
74 #ifdef __GNUC__
75 #  define LIKELY(x) __builtin_expect(!!(x), 1)
76 #  define UNLIKELY(x) __builtin_expect(!!(x), 0)
77 #else
78 #  define LIKELY(x) (x)
79 #  define UNLIKELY(x) (x)
80 #endif
81
82 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__)
83 // Needed for memalign on Linux and _aligned_alloc on Windows.
84
85 #  include <malloc.h>
86 #else
87 // Apple's malloc is 16-byte aligned, and does not have malloc.h, so include
88 // stdilb instead.
89 #  include <stdlib.h>
90 #endif
91
92 /* visual studio 2012 does not define inline for C */
93 #ifdef _MSC_VER
94 #  define MEM_INLINE static __inline
95 #else
96 #  define MEM_INLINE static inline
97 #endif
98
99 #define IS_POW2(a) (((a) & ((a)-1)) == 0)
100
101 /* Extra padding which needs to be applied on MemHead to make it aligned. */
102 #define MEMHEAD_ALIGN_PADDING(alignment) \
103   ((size_t)alignment - (sizeof(MemHeadAligned) % (size_t)alignment))
104
105 /* Real pointer returned by the malloc or aligned_alloc. */
106 #define MEMHEAD_REAL_PTR(memh) ((char *)memh - MEMHEAD_ALIGN_PADDING(memh->alignment))
107
108 #include "mallocn_inline.h"
109
110 #define ALIGNED_MALLOC_MINIMUM_ALIGNMENT sizeof(void *)
111
112 void *aligned_malloc(size_t size, size_t alignment);
113 void aligned_free(void *ptr);
114
115 /* Prototypes for counted allocator functions */
116 size_t MEM_lockfree_allocN_len(const void *vmemh) ATTR_WARN_UNUSED_RESULT;
117 void MEM_lockfree_freeN(void *vmemh);
118 void *MEM_lockfree_dupallocN(const void *vmemh) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
119 void *MEM_lockfree_reallocN_id(void *vmemh,
120                                size_t len,
121                                const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
122     ATTR_ALLOC_SIZE(2);
123 void *MEM_lockfree_recallocN_id(void *vmemh,
124                                 size_t len,
125                                 const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
126     ATTR_ALLOC_SIZE(2);
127 void *MEM_lockfree_callocN(size_t len, const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
128     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
129 void *MEM_lockfree_calloc_arrayN(size_t len,
130                                  size_t size,
131                                  const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
132     ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);
133 void *MEM_lockfree_mallocN(size_t len, const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
134     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
135 void *MEM_lockfree_malloc_arrayN(size_t len,
136                                  size_t size,
137                                  const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
138     ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);
139 void *MEM_lockfree_mallocN_aligned(size_t len,
140                                    size_t alignment,
141                                    const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
142     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(3);
143 void *MEM_lockfree_mapallocN(size_t len,
144                              const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
145     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
146 void MEM_lockfree_printmemlist_pydict(void);
147 void MEM_lockfree_printmemlist(void);
148 void MEM_lockfree_callbackmemlist(void (*func)(void *));
149 void MEM_lockfree_printmemlist_stats(void);
150 void MEM_lockfree_set_error_callback(void (*func)(const char *));
151 bool MEM_lockfree_consistency_check(void);
152 void MEM_lockfree_set_lock_callback(void (*lock)(void), void (*unlock)(void));
153 void MEM_lockfree_set_memory_debug(void);
154 size_t MEM_lockfree_get_memory_in_use(void);
155 size_t MEM_lockfree_get_mapped_memory_in_use(void);
156 unsigned int MEM_lockfree_get_memory_blocks_in_use(void);
157 void MEM_lockfree_reset_peak_memory(void);
158 size_t MEM_lockfree_get_peak_memory(void) ATTR_WARN_UNUSED_RESULT;
159 #ifndef NDEBUG
160 const char *MEM_lockfree_name_ptr(void *vmemh);
161 #endif
162
163 /* Prototypes for fully guarded allocator functions */
164 size_t MEM_guarded_allocN_len(const void *vmemh) ATTR_WARN_UNUSED_RESULT;
165 void MEM_guarded_freeN(void *vmemh);
166 void *MEM_guarded_dupallocN(const void *vmemh) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
167 void *MEM_guarded_reallocN_id(void *vmemh,
168                               size_t len,
169                               const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
170     ATTR_ALLOC_SIZE(2);
171 void *MEM_guarded_recallocN_id(void *vmemh,
172                                size_t len,
173                                const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
174     ATTR_ALLOC_SIZE(2);
175 void *MEM_guarded_callocN(size_t len, const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
176     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
177 void *MEM_guarded_calloc_arrayN(size_t len,
178                                 size_t size,
179                                 const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
180     ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);
181 void *MEM_guarded_mallocN(size_t len, const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
182     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
183 void *MEM_guarded_malloc_arrayN(size_t len,
184                                 size_t size,
185                                 const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
186     ATTR_ALLOC_SIZE(1, 2) ATTR_NONNULL(3);
187 void *MEM_guarded_mallocN_aligned(size_t len,
188                                   size_t alignment,
189                                   const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
190     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(3);
191 void *MEM_guarded_mapallocN(size_t len,
192                             const char *UNUSED(str)) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
193     ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2);
194 void MEM_guarded_printmemlist_pydict(void);
195 void MEM_guarded_printmemlist(void);
196 void MEM_guarded_callbackmemlist(void (*func)(void *));
197 void MEM_guarded_printmemlist_stats(void);
198 void MEM_guarded_set_error_callback(void (*func)(const char *));
199 bool MEM_guarded_consistency_check(void);
200 void MEM_guarded_set_lock_callback(void (*lock)(void), void (*unlock)(void));
201 void MEM_guarded_set_memory_debug(void);
202 size_t MEM_guarded_get_memory_in_use(void);
203 size_t MEM_guarded_get_mapped_memory_in_use(void);
204 unsigned int MEM_guarded_get_memory_blocks_in_use(void);
205 void MEM_guarded_reset_peak_memory(void);
206 size_t MEM_guarded_get_peak_memory(void) ATTR_WARN_UNUSED_RESULT;
207 #ifndef NDEBUG
208 const char *MEM_guarded_name_ptr(void *vmemh);
209 #endif
210
211 #endif /* __MALLOCN_INTERN_H__ */