ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cf.schmorp.de/Deliantra-Client/ecb.h
Revision: 1.3
Committed: Sat Jan 11 02:10:03 2020 UTC (4 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.2: +22 -12 lines
Log Message:
*** empty log message ***

File Contents

# Content
1 /*
2 * libecb - http://software.schmorp.de/pkg/libecb
3 *
4 * Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
5 * Copyright (©) 2011 Emanuele Giaquinta
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without modifica-
9 * tion, are permitted provided that the following conditions are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright notice,
12 * this list of conditions and the following disclaimer.
13 *
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
20 * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
21 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
22 * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
24 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
26 * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
27 * OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * Alternatively, the contents of this file may be used under the terms of
30 * the GNU General Public License ("GPL") version 2 or any later version,
31 * in which case the provisions of the GPL are applicable instead of
32 * the above. If you wish to allow the use of your version of this file
33 * only under the terms of the GPL and not to allow others to use your
34 * version of this file under the BSD license, indicate your decision
35 * by deleting the provisions above and replace them with the notice
36 * and other provisions required by the GPL. If you do not delete the
37 * provisions above, a recipient may use your version of this file under
38 * either the BSD or the GPL.
39 */
40
41 #ifndef ECB_H
42 #define ECB_H
43
44 /* 16 bits major, 16 bits minor */
45 #define ECB_VERSION 0x00010007
46
47 #ifdef _WIN32
48 typedef signed char int8_t;
49 typedef unsigned char uint8_t;
50 typedef signed short int16_t;
51 typedef unsigned short uint16_t;
52 typedef signed int int32_t;
53 typedef unsigned int uint32_t;
54 #if __GNUC__
55 typedef signed long long int64_t;
56 typedef unsigned long long uint64_t;
57 #else /* _MSC_VER || __BORLANDC__ */
58 typedef signed __int64 int64_t;
59 typedef unsigned __int64 uint64_t;
60 #endif
61 #ifdef _WIN64
62 #define ECB_PTRSIZE 8
63 typedef uint64_t uintptr_t;
64 typedef int64_t intptr_t;
65 #else
66 #define ECB_PTRSIZE 4
67 typedef uint32_t uintptr_t;
68 typedef int32_t intptr_t;
69 #endif
70 #else
71 #include <inttypes.h>
72 #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
73 #define ECB_PTRSIZE 8
74 #else
75 #define ECB_PTRSIZE 4
76 #endif
77 #endif
78
79 #define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
80 #define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
81
82 #ifndef ECB_OPTIMIZE_SIZE
83 #if __OPTIMIZE_SIZE__
84 #define ECB_OPTIMIZE_SIZE 1
85 #else
86 #define ECB_OPTIMIZE_SIZE 0
87 #endif
88 #endif
89
90 /* work around x32 idiocy by defining proper macros */
91 #if ECB_GCC_AMD64 || ECB_MSVC_AMD64
92 #if _ILP32
93 #define ECB_AMD64_X32 1
94 #else
95 #define ECB_AMD64 1
96 #endif
97 #endif
98
99 /* many compilers define _GNUC_ to some versions but then only implement
100 * what their idiot authors think are the "more important" extensions,
101 * causing enormous grief in return for some better fake benchmark numbers.
102 * or so.
103 * we try to detect these and simply assume they are not gcc - if they have
104 * an issue with that they should have done it right in the first place.
105 */
106 #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
107 #define ECB_GCC_VERSION(major,minor) 0
108 #else
109 #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
110 #endif
111
112 #define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
113
114 #if __clang__ && defined __has_builtin
115 #define ECB_CLANG_BUILTIN(x) __has_builtin (x)
116 #else
117 #define ECB_CLANG_BUILTIN(x) 0
118 #endif
119
120 #if __clang__ && defined __has_extension
121 #define ECB_CLANG_EXTENSION(x) __has_extension (x)
122 #else
123 #define ECB_CLANG_EXTENSION(x) 0
124 #endif
125
126 #define ECB_CPP (__cplusplus+0)
127 #define ECB_CPP11 (__cplusplus >= 201103L)
128 #define ECB_CPP14 (__cplusplus >= 201402L)
129 #define ECB_CPP17 (__cplusplus >= 201703L)
130
131 #if ECB_CPP
132 #define ECB_C 0
133 #define ECB_STDC_VERSION 0
134 #else
135 #define ECB_C 1
136 #define ECB_STDC_VERSION __STDC_VERSION__
137 #endif
138
139 #define ECB_C99 (ECB_STDC_VERSION >= 199901L)
140 #define ECB_C11 (ECB_STDC_VERSION >= 201112L)
141 #define ECB_C17 (ECB_STDC_VERSION >= 201710L)
142
143 #if ECB_CPP
144 #define ECB_EXTERN_C extern "C"
145 #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
146 #define ECB_EXTERN_C_END }
147 #else
148 #define ECB_EXTERN_C extern
149 #define ECB_EXTERN_C_BEG
150 #define ECB_EXTERN_C_END
151 #endif
152
153 /*****************************************************************************/
154
155 /* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
156 /* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
157
158 #if ECB_NO_THREADS
159 #define ECB_NO_SMP 1
160 #endif
161
162 #if ECB_NO_SMP
163 #define ECB_MEMORY_FENCE do { } while (0)
164 #endif
165
166 /* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
167 #if __xlC__ && ECB_CPP
168 #include <builtins.h>
169 #endif
170
171 #if 1400 <= _MSC_VER
172 #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
173 #endif
174
175 #ifndef ECB_MEMORY_FENCE
176 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
177 #define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
178 #if __i386 || __i386__
179 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
180 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
181 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
182 #elif ECB_GCC_AMD64
183 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
184 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
185 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
186 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
187 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
188 #elif defined __ARM_ARCH_2__ \
189 || defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
190 || defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
191 || defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
192 || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
193 || defined __ARM_ARCH_5TEJ__
194 /* should not need any, unless running old code on newer cpu - arm doesn't support that */
195 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
196 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
197 || defined __ARM_ARCH_6T2__
198 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
199 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
200 || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
201 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
202 #elif __aarch64__
203 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
204 #elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
205 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
206 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
207 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
208 #elif defined __s390__ || defined __s390x__
209 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
210 #elif defined __mips__
211 /* GNU/Linux emulates sync on mips1 architectures, so we force its use */
212 /* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
213 #define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
214 #elif defined __alpha__
215 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
216 #elif defined __hppa__
217 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
218 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
219 #elif defined __ia64__
220 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
221 #elif defined __m68k__
222 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
223 #elif defined __m88k__
224 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
225 #elif defined __sh__
226 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
227 #endif
228 #endif
229 #endif
230
231 #ifndef ECB_MEMORY_FENCE
232 #if ECB_GCC_VERSION(4,7)
233 /* see comment below (stdatomic.h) about the C11 memory model. */
234 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
235 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
236 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
237 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
238
239 #elif ECB_CLANG_EXTENSION(c_atomic)
240 /* see comment below (stdatomic.h) about the C11 memory model. */
241 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
242 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
243 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
244 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
245
246 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
247 #define ECB_MEMORY_FENCE __sync_synchronize ()
248 #elif _MSC_VER >= 1500 /* VC++ 2008 */
249 /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
250 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
251 #define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
252 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
253 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
254 #elif _MSC_VER >= 1400 /* VC++ 2005 */
255 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
256 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
257 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
258 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
259 #elif defined _WIN32
260 #include <WinNT.h>
261 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
262 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
263 #include <mbarrier.h>
264 #define ECB_MEMORY_FENCE __machine_rw_barrier ()
265 #define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
266 #define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
267 #define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
268 #elif __xlC__
269 #define ECB_MEMORY_FENCE __sync ()
270 #endif
271 #endif
272
273 #ifndef ECB_MEMORY_FENCE
274 #if ECB_C11 && !defined __STDC_NO_ATOMICS__
275 /* we assume that these memory fences work on all variables/all memory accesses, */
276 /* not just C11 atomics and atomic accesses */
277 #include <stdatomic.h>
278 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
279 #define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
280 #define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
281 #endif
282 #endif
283
284 #ifndef ECB_MEMORY_FENCE
285 #if !ECB_AVOID_PTHREADS
286 /*
287 * if you get undefined symbol references to pthread_mutex_lock,
288 * or failure to find pthread.h, then you should implement
289 * the ECB_MEMORY_FENCE operations for your cpu/compiler
290 * OR provide pthread.h and link against the posix thread library
291 * of your system.
292 */
293 #include <pthread.h>
294 #define ECB_NEEDS_PTHREADS 1
295 #define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
296
297 static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
298 #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
299 #endif
300 #endif
301
302 #if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
303 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
304 #endif
305
306 #if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
307 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
308 #endif
309
310 #if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
311 #define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
312 #endif
313
314 /*****************************************************************************/
315
316 #if ECB_CPP
317 #define ecb_inline static inline
318 #elif ECB_GCC_VERSION(2,5)
319 #define ecb_inline static __inline__
320 #elif ECB_C99
321 #define ecb_inline static inline
322 #else
323 #define ecb_inline static
324 #endif
325
326 #if ECB_GCC_VERSION(3,3)
327 #define ecb_restrict __restrict__
328 #elif ECB_C99
329 #define ecb_restrict restrict
330 #else
331 #define ecb_restrict
332 #endif
333
334 typedef int ecb_bool;
335
336 #define ECB_CONCAT_(a, b) a ## b
337 #define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
338 #define ECB_STRINGIFY_(a) # a
339 #define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
340 #define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
341
342 #define ecb_function_ ecb_inline
343
344 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
345 #define ecb_attribute(attrlist) __attribute__ (attrlist)
346 #else
347 #define ecb_attribute(attrlist)
348 #endif
349
350 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
351 #define ecb_is_constant(expr) __builtin_constant_p (expr)
352 #else
353 /* possible C11 impl for integral types
354 typedef struct ecb_is_constant_struct ecb_is_constant_struct;
355 #define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
356
357 #define ecb_is_constant(expr) 0
358 #endif
359
360 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
361 #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
362 #else
363 #define ecb_expect(expr,value) (expr)
364 #endif
365
366 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
367 #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
368 #else
369 #define ecb_prefetch(addr,rw,locality)
370 #endif
371
372 /* no emulation for ecb_decltype */
373 #if ECB_CPP11
374 // older implementations might have problems with decltype(x)::type, work around it
375 template<class T> struct ecb_decltype_t { typedef T type; };
376 #define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
377 #elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
378 #define ecb_decltype(x) __typeof__ (x)
379 #endif
380
381 #if _MSC_VER >= 1300
382 #define ecb_deprecated __declspec (deprecated)
383 #else
384 #define ecb_deprecated ecb_attribute ((__deprecated__))
385 #endif
386
387 #if _MSC_VER >= 1500
388 #define ecb_deprecated_message(msg) __declspec (deprecated (msg))
389 #elif ECB_GCC_VERSION(4,5)
390 #define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
391 #else
392 #define ecb_deprecated_message(msg) ecb_deprecated
393 #endif
394
395 #if _MSC_VER >= 1400
396 #define ecb_noinline __declspec (noinline)
397 #else
398 #define ecb_noinline ecb_attribute ((__noinline__))
399 #endif
400
401 #define ecb_unused ecb_attribute ((__unused__))
402 #define ecb_const ecb_attribute ((__const__))
403 #define ecb_pure ecb_attribute ((__pure__))
404
405 #if ECB_C11 || __IBMC_NORETURN
406 /* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
407 #define ecb_noreturn _Noreturn
408 #elif ECB_CPP11
409 #define ecb_noreturn [[noreturn]]
410 #elif _MSC_VER >= 1200
411 /* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
412 #define ecb_noreturn __declspec (noreturn)
413 #else
414 #define ecb_noreturn ecb_attribute ((__noreturn__))
415 #endif
416
417 #if ECB_GCC_VERSION(4,3)
418 #define ecb_artificial ecb_attribute ((__artificial__))
419 #define ecb_hot ecb_attribute ((__hot__))
420 #define ecb_cold ecb_attribute ((__cold__))
421 #else
422 #define ecb_artificial
423 #define ecb_hot
424 #define ecb_cold
425 #endif
426
427 /* put around conditional expressions if you are very sure that the */
428 /* expression is mostly true or mostly false. note that these return */
429 /* booleans, not the expression. */
430 #define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
431 #define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
432 /* for compatibility to the rest of the world */
433 #define ecb_likely(expr) ecb_expect_true (expr)
434 #define ecb_unlikely(expr) ecb_expect_false (expr)
435
436 /* count trailing zero bits and count # of one bits */
437 #if ECB_GCC_VERSION(3,4) \
438 || (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
439 && ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
440 && ECB_CLANG_BUILTIN(__builtin_popcount))
441 /* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
442 #define ecb_ld32(x) (__builtin_clz (x) ^ 31)
443 #define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
444 #define ecb_ctz32(x) __builtin_ctz (x)
445 #define ecb_ctz64(x) __builtin_ctzll (x)
446 #define ecb_popcount32(x) __builtin_popcount (x)
447 /* no popcountll */
448 #else
449 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
450 ecb_function_ ecb_const int
451 ecb_ctz32 (uint32_t x)
452 {
453 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
454 unsigned long r;
455 _BitScanForward (&r, x);
456 return (int)r;
457 #else
458 int r = 0;
459
460 x &= ~x + 1; /* this isolates the lowest bit */
461
462 #if ECB_branchless_on_i386
463 r += !!(x & 0xaaaaaaaa) << 0;
464 r += !!(x & 0xcccccccc) << 1;
465 r += !!(x & 0xf0f0f0f0) << 2;
466 r += !!(x & 0xff00ff00) << 3;
467 r += !!(x & 0xffff0000) << 4;
468 #else
469 if (x & 0xaaaaaaaa) r += 1;
470 if (x & 0xcccccccc) r += 2;
471 if (x & 0xf0f0f0f0) r += 4;
472 if (x & 0xff00ff00) r += 8;
473 if (x & 0xffff0000) r += 16;
474 #endif
475
476 return r;
477 #endif
478 }
479
480 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
481 ecb_function_ ecb_const int
482 ecb_ctz64 (uint64_t x)
483 {
484 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
485 unsigned long r;
486 _BitScanForward64 (&r, x);
487 return (int)r;
488 #else
489 int shift = x & 0xffffffff ? 0 : 32;
490 return ecb_ctz32 (x >> shift) + shift;
491 #endif
492 }
493
494 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
495 ecb_function_ ecb_const int
496 ecb_popcount32 (uint32_t x)
497 {
498 x -= (x >> 1) & 0x55555555;
499 x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
500 x = ((x >> 4) + x) & 0x0f0f0f0f;
501 x *= 0x01010101;
502
503 return x >> 24;
504 }
505
506 ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
507 ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
508 {
509 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
510 unsigned long r;
511 _BitScanReverse (&r, x);
512 return (int)r;
513 #else
514 int r = 0;
515
516 if (x >> 16) { x >>= 16; r += 16; }
517 if (x >> 8) { x >>= 8; r += 8; }
518 if (x >> 4) { x >>= 4; r += 4; }
519 if (x >> 2) { x >>= 2; r += 2; }
520 if (x >> 1) { r += 1; }
521
522 return r;
523 #endif
524 }
525
526 ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
527 ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
528 {
529 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
530 unsigned long r;
531 _BitScanReverse64 (&r, x);
532 return (int)r;
533 #else
534 int r = 0;
535
536 if (x >> 32) { x >>= 32; r += 32; }
537
538 return r + ecb_ld32 (x);
539 #endif
540 }
541 #endif
542
543 ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
544 ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
545 ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
546 ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
547
548 ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
549 ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
550 {
551 return ( (x * 0x0802U & 0x22110U)
552 | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
553 }
554
555 ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
556 ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
557 {
558 x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
559 x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
560 x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
561 x = ( x >> 8 ) | ( x << 8);
562
563 return x;
564 }
565
566 ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
567 ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
568 {
569 x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
570 x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
571 x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
572 x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
573 x = ( x >> 16 ) | ( x << 16);
574
575 return x;
576 }
577
578 /* popcount64 is only available on 64 bit cpus as gcc builtin */
579 /* so for this version we are lazy */
580 ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
581 ecb_function_ ecb_const int
582 ecb_popcount64 (uint64_t x)
583 {
584 return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
585 }
586
587 ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
588 ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
589 ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
590 ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
591 ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
592 ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
593 ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
594 ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
595
596 ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
597 ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
598 ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
599 ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
600 ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
601 ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
602 ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
603 ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
604
605 #if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
606 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
607 #define ecb_bswap16(x) __builtin_bswap16 (x)
608 #else
609 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
610 #endif
611 #define ecb_bswap32(x) __builtin_bswap32 (x)
612 #define ecb_bswap64(x) __builtin_bswap64 (x)
613 #elif _MSC_VER
614 #include <stdlib.h>
615 #define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
616 #define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
617 #define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
618 #else
619 ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
620 ecb_function_ ecb_const uint16_t
621 ecb_bswap16 (uint16_t x)
622 {
623 return ecb_rotl16 (x, 8);
624 }
625
626 ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
627 ecb_function_ ecb_const uint32_t
628 ecb_bswap32 (uint32_t x)
629 {
630 return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
631 }
632
633 ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
634 ecb_function_ ecb_const uint64_t
635 ecb_bswap64 (uint64_t x)
636 {
637 return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
638 }
639 #endif
640
641 #if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
642 #define ecb_unreachable() __builtin_unreachable ()
643 #else
644 /* this seems to work fine, but gcc always emits a warning for it :/ */
645 ecb_inline ecb_noreturn void ecb_unreachable (void);
646 ecb_inline ecb_noreturn void ecb_unreachable (void) { }
647 #endif
648
649 /* try to tell the compiler that some condition is definitely true */
650 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
651
652 ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
653 ecb_inline ecb_const uint32_t
654 ecb_byteorder_helper (void)
655 {
656 /* the union code still generates code under pressure in gcc, */
657 /* but less than using pointers, and always seems to */
658 /* successfully return a constant. */
659 /* the reason why we have this horrible preprocessor mess */
660 /* is to avoid it in all cases, at least on common architectures */
661 /* or when using a recent enough gcc version (>= 4.6) */
662 #if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
663 || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
664 #define ECB_LITTLE_ENDIAN 1
665 return 0x44332211;
666 #elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
667 || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
668 #define ECB_BIG_ENDIAN 1
669 return 0x11223344;
670 #else
671 union
672 {
673 uint8_t c[4];
674 uint32_t u;
675 } u = { 0x11, 0x22, 0x33, 0x44 };
676 return u.u;
677 #endif
678 }
679
680 ecb_inline ecb_const ecb_bool ecb_big_endian (void);
681 ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
682 ecb_inline ecb_const ecb_bool ecb_little_endian (void);
683 ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
684
685 #if ECB_GCC_VERSION(3,0) || ECB_C99
686 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
687 #else
688 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
689 #endif
690
691 #if ECB_CPP
692 template<typename T>
693 static inline T ecb_div_rd (T val, T div)
694 {
695 return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
696 }
697 template<typename T>
698 static inline T ecb_div_ru (T val, T div)
699 {
700 return val < 0 ? - ((-val ) / div) : (val + div - 1) / div;
701 }
702 #else
703 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
704 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
705 #endif
706
707 #if ecb_cplusplus_does_not_suck
708 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
709 template<typename T, int N>
710 static inline int ecb_array_length (const T (&arr)[N])
711 {
712 return N;
713 }
714 #else
715 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
716 #endif
717
718 ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
719 ecb_function_ ecb_const uint32_t
720 ecb_binary16_to_binary32 (uint32_t x)
721 {
722 unsigned int s = (x & 0x8000) << (31 - 15);
723 int e = (x >> 10) & 0x001f;
724 unsigned int m = x & 0x03ff;
725
726 if (ecb_expect_false (e == 31))
727 /* infinity or NaN */
728 e = 255 - (127 - 15);
729 else if (ecb_expect_false (!e))
730 {
731 if (ecb_expect_true (!m))
732 /* zero, handled by code below by forcing e to 0 */
733 e = 0 - (127 - 15);
734 else
735 {
736 /* subnormal, renormalise */
737 unsigned int s = 10 - ecb_ld32 (m);
738
739 m = (m << s) & 0x3ff; /* mask implicit bit */
740 e -= s - 1;
741 }
742 }
743
744 /* e and m now are normalised, or zero, (or inf or nan) */
745 e += 127 - 15;
746
747 return s | (e << 23) | (m << (23 - 10));
748 }
749
750 ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
751 ecb_function_ ecb_const uint16_t
752 ecb_binary32_to_binary16 (uint32_t x)
753 {
754 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
755 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
756 unsigned int m = x & 0x007fffff;
757
758 x &= 0x7fffffff;
759
760 /* if it's within range of binary16 normals, use fast path */
761 if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
762 {
763 /* mantissa round-to-even */
764 m += 0x00000fff + ((m >> (23 - 10)) & 1);
765
766 /* handle overflow */
767 if (ecb_expect_false (m >= 0x00800000))
768 {
769 m >>= 1;
770 e += 1;
771 }
772
773 return s | (e << 10) | (m >> (23 - 10));
774 }
775
776 /* handle large numbers and infinity */
777 if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
778 return s | 0x7c00;
779
780 /* handle zero, subnormals and small numbers */
781 if (ecb_expect_true (x < 0x38800000))
782 {
783 /* zero */
784 if (ecb_expect_true (!x))
785 return s;
786
787 /* handle subnormals */
788
789 /* too small, will be zero */
790 if (e < (14 - 24)) /* might not be sharp, but is good enough */
791 return s;
792
793 m |= 0x00800000; /* make implicit bit explicit */
794
795 /* very tricky - we need to round to the nearest e (+10) bit value */
796 {
797 unsigned int bits = 14 - e;
798 unsigned int half = (1 << (bits - 1)) - 1;
799 unsigned int even = (m >> bits) & 1;
800
801 /* if this overflows, we will end up with a normalised number */
802 m = (m + half + even) >> bits;
803 }
804
805 return s | m;
806 }
807
808 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
809 m >>= 13;
810
811 return s | 0x7c00 | m | !m;
812 }
813
814 /*******************************************************************************/
815 /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
816
817 /* basically, everything uses "ieee pure-endian" floating point numbers */
818 /* the only noteworthy exception is ancient armle, which uses order 43218765 */
819 #if 0 \
820 || __i386 || __i386__ \
821 || ECB_GCC_AMD64 \
822 || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
823 || defined __s390__ || defined __s390x__ \
824 || defined __mips__ \
825 || defined __alpha__ \
826 || defined __hppa__ \
827 || defined __ia64__ \
828 || defined __m68k__ \
829 || defined __m88k__ \
830 || defined __sh__ \
831 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
832 || (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
833 || defined __aarch64__
834 #define ECB_STDFP 1
835 #include <string.h> /* for memcpy */
836 #else
837 #define ECB_STDFP 0
838 #endif
839
840 #ifndef ECB_NO_LIBM
841
842 #include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
843
844 /* only the oldest of old doesn't have this one. solaris. */
845 #ifdef INFINITY
846 #define ECB_INFINITY INFINITY
847 #else
848 #define ECB_INFINITY HUGE_VAL
849 #endif
850
851 #ifdef NAN
852 #define ECB_NAN NAN
853 #else
854 #define ECB_NAN ECB_INFINITY
855 #endif
856
857 #if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
858 #define ecb_ldexpf(x,e) ldexpf ((x), (e))
859 #define ecb_frexpf(x,e) frexpf ((x), (e))
860 #else
861 #define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
862 #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
863 #endif
864
865 /* convert a float to ieee single/binary32 */
866 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
867 ecb_function_ ecb_const uint32_t
868 ecb_float_to_binary32 (float x)
869 {
870 uint32_t r;
871
872 #if ECB_STDFP
873 memcpy (&r, &x, 4);
874 #else
875 /* slow emulation, works for anything but -0 */
876 uint32_t m;
877 int e;
878
879 if (x == 0e0f ) return 0x00000000U;
880 if (x > +3.40282346638528860e+38f) return 0x7f800000U;
881 if (x < -3.40282346638528860e+38f) return 0xff800000U;
882 if (x != x ) return 0x7fbfffffU;
883
884 m = ecb_frexpf (x, &e) * 0x1000000U;
885
886 r = m & 0x80000000U;
887
888 if (r)
889 m = -m;
890
891 if (e <= -126)
892 {
893 m &= 0xffffffU;
894 m >>= (-125 - e);
895 e = -126;
896 }
897
898 r |= (e + 126) << 23;
899 r |= m & 0x7fffffU;
900 #endif
901
902 return r;
903 }
904
905 /* converts an ieee single/binary32 to a float */
906 ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
907 ecb_function_ ecb_const float
908 ecb_binary32_to_float (uint32_t x)
909 {
910 float r;
911
912 #if ECB_STDFP
913 memcpy (&r, &x, 4);
914 #else
915 /* emulation, only works for normals and subnormals and +0 */
916 int neg = x >> 31;
917 int e = (x >> 23) & 0xffU;
918
919 x &= 0x7fffffU;
920
921 if (e)
922 x |= 0x800000U;
923 else
924 e = 1;
925
926 /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
927 r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
928
929 r = neg ? -r : r;
930 #endif
931
932 return r;
933 }
934
935 /* convert a double to ieee double/binary64 */
936 ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
937 ecb_function_ ecb_const uint64_t
938 ecb_double_to_binary64 (double x)
939 {
940 uint64_t r;
941
942 #if ECB_STDFP
943 memcpy (&r, &x, 8);
944 #else
945 /* slow emulation, works for anything but -0 */
946 uint64_t m;
947 int e;
948
949 if (x == 0e0 ) return 0x0000000000000000U;
950 if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
951 if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
952 if (x != x ) return 0X7ff7ffffffffffffU;
953
954 m = frexp (x, &e) * 0x20000000000000U;
955
956 r = m & 0x8000000000000000;;
957
958 if (r)
959 m = -m;
960
961 if (e <= -1022)
962 {
963 m &= 0x1fffffffffffffU;
964 m >>= (-1021 - e);
965 e = -1022;
966 }
967
968 r |= ((uint64_t)(e + 1022)) << 52;
969 r |= m & 0xfffffffffffffU;
970 #endif
971
972 return r;
973 }
974
975 /* converts an ieee double/binary64 to a double */
976 ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
977 ecb_function_ ecb_const double
978 ecb_binary64_to_double (uint64_t x)
979 {
980 double r;
981
982 #if ECB_STDFP
983 memcpy (&r, &x, 8);
984 #else
985 /* emulation, only works for normals and subnormals and +0 */
986 int neg = x >> 63;
987 int e = (x >> 52) & 0x7ffU;
988
989 x &= 0xfffffffffffffU;
990
991 if (e)
992 x |= 0x10000000000000U;
993 else
994 e = 1;
995
996 /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
997 r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
998
999 r = neg ? -r : r;
1000 #endif
1001
1002 return r;
1003 }
1004
1005 /* convert a float to ieee half/binary16 */
1006 ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
1007 ecb_function_ ecb_const uint16_t
1008 ecb_float_to_binary16 (float x)
1009 {
1010 return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
1011 }
1012
1013 /* convert an ieee half/binary16 to float */
1014 ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
1015 ecb_function_ ecb_const float
1016 ecb_binary16_to_float (uint16_t x)
1017 {
1018 return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
1019 }
1020
1021 #endif
1022
1023 #endif
1024