ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libecb/ecb.h
(Generate patch)

Comparing libecb/ecb.h (file contents):
Revision 1.160 by sf-exg, Thu Mar 19 15:43:51 2015 UTC vs.
Revision 1.180 by root, Mon Jan 20 13:13:56 2020 UTC

… …
40 40
41#ifndef ECB_H 41#ifndef ECB_H
42#define ECB_H 42#define ECB_H
43 43
44/* 16 bits major, 16 bits minor */ 44/* 16 bits major, 16 bits minor */
45#define ECB_VERSION 0x00010004 45#define ECB_VERSION 0x00010008
46 46
47#ifdef _WIN32 47#ifdef _WIN32
48 typedef signed char int8_t; 48 typedef signed char int8_t;
49 typedef unsigned char uint8_t; 49 typedef unsigned char uint8_t;
50 typedef signed char int_fast8_t;
51 typedef unsigned char uint_fast8_t;
50 typedef signed short int16_t; 52 typedef signed short int16_t;
51 typedef unsigned short uint16_t; 53 typedef unsigned short uint16_t;
54 typedef signed int int_fast16_t;
55 typedef unsigned int uint_fast16_t;
52 typedef signed int int32_t; 56 typedef signed int int32_t;
53 typedef unsigned int uint32_t; 57 typedef unsigned int uint32_t;
58 typedef signed int int_fast32_t;
59 typedef unsigned int uint_fast32_t;
54 #if __GNUC__ 60 #if __GNUC__
55 typedef signed long long int64_t; 61 typedef signed long long int64_t;
56 typedef unsigned long long uint64_t; 62 typedef unsigned long long uint64_t;
57 #else /* _MSC_VER || __BORLANDC__ */ 63 #else /* _MSC_VER || __BORLANDC__ */
58 typedef signed __int64 int64_t; 64 typedef signed __int64 int64_t;
59 typedef unsigned __int64 uint64_t; 65 typedef unsigned __int64 uint64_t;
60 #endif 66 #endif
67 typedef int64_t int_fast64_t;
68 typedef uint64_t uint_fast64_t;
61 #ifdef _WIN64 69 #ifdef _WIN64
62 #define ECB_PTRSIZE 8 70 #define ECB_PTRSIZE 8
63 typedef uint64_t uintptr_t; 71 typedef uint64_t uintptr_t;
64 typedef int64_t intptr_t; 72 typedef int64_t intptr_t;
65 #else 73 #else
… …
67 typedef uint32_t uintptr_t; 75 typedef uint32_t uintptr_t;
68 typedef int32_t intptr_t; 76 typedef int32_t intptr_t;
69 #endif 77 #endif
70#else 78#else
71 #include <inttypes.h> 79 #include <inttypes.h>
72 #if UINTMAX_MAX > 0xffffffffU 80 #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
73 #define ECB_PTRSIZE 8 81 #define ECB_PTRSIZE 8
74 #else 82 #else
75 #define ECB_PTRSIZE 4 83 #define ECB_PTRSIZE 4
76 #endif 84 #endif
77#endif 85#endif
78 86
79#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__) 87#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
80#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64) 88#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
89
90#ifndef ECB_OPTIMIZE_SIZE
91 #if __OPTIMIZE_SIZE__
92 #define ECB_OPTIMIZE_SIZE 1
93 #else
94 #define ECB_OPTIMIZE_SIZE 0
95 #endif
96#endif
81 97
82/* work around x32 idiocy by defining proper macros */ 98/* work around x32 idiocy by defining proper macros */
83#if ECB_GCC_AMD64 || ECB_MSVC_AMD64 99#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
84 #if _ILP32 100 #if _ILP32
85 #define ECB_AMD64_X32 1 101 #define ECB_AMD64_X32 1
… …
115 #define ECB_CLANG_EXTENSION(x) 0 131 #define ECB_CLANG_EXTENSION(x) 0
116#endif 132#endif
117 133
118#define ECB_CPP (__cplusplus+0) 134#define ECB_CPP (__cplusplus+0)
119#define ECB_CPP11 (__cplusplus >= 201103L) 135#define ECB_CPP11 (__cplusplus >= 201103L)
136#define ECB_CPP14 (__cplusplus >= 201402L)
137#define ECB_CPP17 (__cplusplus >= 201703L)
120 138
121#if ECB_CPP 139#if ECB_CPP
122 #define ECB_C 0 140 #define ECB_C 0
123 #define ECB_STDC_VERSION 0 141 #define ECB_STDC_VERSION 0
124#else 142#else
… …
126 #define ECB_STDC_VERSION __STDC_VERSION__ 144 #define ECB_STDC_VERSION __STDC_VERSION__
127#endif 145#endif
128 146
129#define ECB_C99 (ECB_STDC_VERSION >= 199901L) 147#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
130#define ECB_C11 (ECB_STDC_VERSION >= 201112L) 148#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
149#define ECB_C17 (ECB_STDC_VERSION >= 201710L)
131 150
132#if ECB_CPP 151#if ECB_CPP
133 #define ECB_EXTERN_C extern "C" 152 #define ECB_EXTERN_C extern "C"
134 #define ECB_EXTERN_C_BEG ECB_EXTERN_C { 153 #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
135 #define ECB_EXTERN_C_END } 154 #define ECB_EXTERN_C_END }
… …
150 169
151#if ECB_NO_SMP 170#if ECB_NO_SMP
152 #define ECB_MEMORY_FENCE do { } while (0) 171 #define ECB_MEMORY_FENCE do { } while (0)
153#endif 172#endif
154 173
174/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
175#if __xlC__ && ECB_CPP
176 #include <builtins.h>
177#endif
178
179#if 1400 <= _MSC_VER
180 #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
181#endif
182
155#ifndef ECB_MEMORY_FENCE 183#ifndef ECB_MEMORY_FENCE
156 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110 184 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
185 #define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
157 #if __i386 || __i386__ 186 #if __i386 || __i386__
158 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory") 187 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
159 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory") 188 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
160 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("") 189 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
161 #elif ECB_GCC_AMD64 190 #elif ECB_GCC_AMD64
162 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory") 191 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
163 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory") 192 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
164 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("") 193 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
165 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ 194 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
166 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 195 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
196 #elif defined __ARM_ARCH_2__ \
197 || defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
198 || defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
199 || defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
200 || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
201 || defined __ARM_ARCH_5TEJ__
202 /* should not need any, unless running old code on newer cpu - arm doesn't support that */
167 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \ 203 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
168 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ 204 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
205 || defined __ARM_ARCH_6T2__
169 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory") 206 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
170 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \ 207 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
171 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__ 208 || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
172 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 209 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
173 #elif __aarch64__ 210 #elif __aarch64__
174 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory") 211 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
175 #elif (__sparc || __sparc__) && !__sparcv8 212 #elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
176 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory") 213 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
177 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory") 214 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
178 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore") 215 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
179 #elif defined __s390__ || defined __s390x__ 216 #elif defined __s390__ || defined __s390x__
180 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory") 217 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
… …
203 #if ECB_GCC_VERSION(4,7) 240 #if ECB_GCC_VERSION(4,7)
204 /* see comment below (stdatomic.h) about the C11 memory model. */ 241 /* see comment below (stdatomic.h) about the C11 memory model. */
205 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 242 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
206 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE) 243 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
207 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE) 244 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
245 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
208 246
209 #elif ECB_CLANG_EXTENSION(c_atomic) 247 #elif ECB_CLANG_EXTENSION(c_atomic)
210 /* see comment below (stdatomic.h) about the C11 memory model. */ 248 /* see comment below (stdatomic.h) about the C11 memory model. */
211 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 249 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
212 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE) 250 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
213 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE) 251 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
252 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
214 253
215 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 254 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
216 #define ECB_MEMORY_FENCE __sync_synchronize () 255 #define ECB_MEMORY_FENCE __sync_synchronize ()
217 #elif _MSC_VER >= 1500 /* VC++ 2008 */ 256 #elif _MSC_VER >= 1500 /* VC++ 2008 */
218 /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */ 257 /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
… …
228 #elif defined _WIN32 267 #elif defined _WIN32
229 #include <WinNT.h> 268 #include <WinNT.h>
230 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */ 269 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
231 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110 270 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
232 #include <mbarrier.h> 271 #include <mbarrier.h>
233 #define ECB_MEMORY_FENCE __machine_rw_barrier () 272 #define ECB_MEMORY_FENCE __machine_rw_barrier ()
234 #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier () 273 #define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
235 #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier () 274 #define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
275 #define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
236 #elif __xlC__ 276 #elif __xlC__
237 #define ECB_MEMORY_FENCE __sync () 277 #define ECB_MEMORY_FENCE __sync ()
238 #endif 278 #endif
239#endif 279#endif
240 280
241#ifndef ECB_MEMORY_FENCE 281#ifndef ECB_MEMORY_FENCE
242 #if ECB_C11 && !defined __STDC_NO_ATOMICS__ 282 #if ECB_C11 && !defined __STDC_NO_ATOMICS__
243 /* we assume that these memory fences work on all variables/all memory accesses, */ 283 /* we assume that these memory fences work on all variables/all memory accesses, */
244 /* not just C11 atomics and atomic accesses */ 284 /* not just C11 atomics and atomic accesses */
245 #include <stdatomic.h> 285 #include <stdatomic.h>
246 /* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
247 /* any fence other than seq_cst, which isn't very efficient for us. */
248 /* Why that is, we don't know - either the C11 memory model is quite useless */
249 /* for most usages, or gcc and clang have a bug */
250 /* I *currently* lean towards the latter, and inefficiently implement */
251 /* all three of ecb's fences as a seq_cst fence */
252 /* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
253 /* for all __atomic_thread_fence's except seq_cst */
254 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst) 286 #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
287 #define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
288 #define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
255 #endif 289 #endif
256#endif 290#endif
257 291
258#ifndef ECB_MEMORY_FENCE 292#ifndef ECB_MEMORY_FENCE
259 #if !ECB_AVOID_PTHREADS 293 #if !ECB_AVOID_PTHREADS
… …
279 313
280#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE 314#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
281 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE 315 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
282#endif 316#endif
283 317
318#if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
319 #define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
320#endif
321
284/*****************************************************************************/ 322/*****************************************************************************/
285 323
286#if ECB_CPP 324#if ECB_CPP
287 #define ecb_inline static inline 325 #define ecb_inline static inline
288#elif ECB_GCC_VERSION(2,5) 326#elif ECB_GCC_VERSION(2,5)
… …
352 #define ecb_deprecated __declspec (deprecated) 390 #define ecb_deprecated __declspec (deprecated)
353#else 391#else
354 #define ecb_deprecated ecb_attribute ((__deprecated__)) 392 #define ecb_deprecated ecb_attribute ((__deprecated__))
355#endif 393#endif
356 394
357#if __MSC_VER >= 1500 395#if _MSC_VER >= 1500
358 #define ecb_deprecated_message(msg) __declspec (deprecated (msg)) 396 #define ecb_deprecated_message(msg) __declspec (deprecated (msg))
359#elif ECB_GCC_VERSION(4,5) 397#elif ECB_GCC_VERSION(4,5)
360 #define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg)) 398 #define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
361#else 399#else
362 #define ecb_deprecated_message(msg) ecb_deprecated 400 #define ecb_deprecated_message(msg) ecb_deprecated
… …
371#define ecb_unused ecb_attribute ((__unused__)) 409#define ecb_unused ecb_attribute ((__unused__))
372#define ecb_const ecb_attribute ((__const__)) 410#define ecb_const ecb_attribute ((__const__))
373#define ecb_pure ecb_attribute ((__pure__)) 411#define ecb_pure ecb_attribute ((__pure__))
374 412
375#if ECB_C11 || __IBMC_NORETURN 413#if ECB_C11 || __IBMC_NORETURN
376 /* http://pic.dhe.ibm.com/infocenter/compbg/v121v141/topic/com.ibm.xlcpp121.bg.doc/language_ref/noreturn.html */ 414 /* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
377 #define ecb_noreturn _Noreturn 415 #define ecb_noreturn _Noreturn
378#elif ECB_CPP11 416#elif ECB_CPP11
379 #define ecb_noreturn [[noreturn]] 417 #define ecb_noreturn [[noreturn]]
380#elif _MSC_VER >= 1200 418#elif _MSC_VER >= 1200
381 /* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */ 419 /* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
… …
418#else 456#else
419 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x); 457 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
420 ecb_function_ ecb_const int 458 ecb_function_ ecb_const int
421 ecb_ctz32 (uint32_t x) 459 ecb_ctz32 (uint32_t x)
422 { 460 {
461#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
462 unsigned long r;
463 _BitScanForward (&r, x);
464 return (int)r;
465#else
423 int r = 0; 466 int r = 0;
424 467
425 x &= ~x + 1; /* this isolates the lowest bit */ 468 x &= ~x + 1; /* this isolates the lowest bit */
426 469
427#if ECB_branchless_on_i386 470#if ECB_branchless_on_i386
… …
437 if (x & 0xff00ff00) r += 8; 480 if (x & 0xff00ff00) r += 8;
438 if (x & 0xffff0000) r += 16; 481 if (x & 0xffff0000) r += 16;
439#endif 482#endif
440 483
441 return r; 484 return r;
485#endif
442 } 486 }
443 487
444 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x); 488 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
445 ecb_function_ ecb_const int 489 ecb_function_ ecb_const int
446 ecb_ctz64 (uint64_t x) 490 ecb_ctz64 (uint64_t x)
447 { 491 {
492#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
493 unsigned long r;
494 _BitScanForward64 (&r, x);
495 return (int)r;
496#else
448 int shift = x & 0xffffffffU ? 0 : 32; 497 int shift = x & 0xffffffff ? 0 : 32;
449 return ecb_ctz32 (x >> shift) + shift; 498 return ecb_ctz32 (x >> shift) + shift;
499#endif
450 } 500 }
451 501
452 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x); 502 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
453 ecb_function_ ecb_const int 503 ecb_function_ ecb_const int
454 ecb_popcount32 (uint32_t x) 504 ecb_popcount32 (uint32_t x)
… …
462 } 512 }
463 513
464 ecb_function_ ecb_const int ecb_ld32 (uint32_t x); 514 ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
465 ecb_function_ ecb_const int ecb_ld32 (uint32_t x) 515 ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
466 { 516 {
517#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
518 unsigned long r;
519 _BitScanReverse (&r, x);
520 return (int)r;
521#else
467 int r = 0; 522 int r = 0;
468 523
469 if (x >> 16) { x >>= 16; r += 16; } 524 if (x >> 16) { x >>= 16; r += 16; }
470 if (x >> 8) { x >>= 8; r += 8; } 525 if (x >> 8) { x >>= 8; r += 8; }
471 if (x >> 4) { x >>= 4; r += 4; } 526 if (x >> 4) { x >>= 4; r += 4; }
472 if (x >> 2) { x >>= 2; r += 2; } 527 if (x >> 2) { x >>= 2; r += 2; }
473 if (x >> 1) { r += 1; } 528 if (x >> 1) { r += 1; }
474 529
475 return r; 530 return r;
531#endif
476 } 532 }
477 533
478 ecb_function_ ecb_const int ecb_ld64 (uint64_t x); 534 ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
479 ecb_function_ ecb_const int ecb_ld64 (uint64_t x) 535 ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
480 { 536 {
537#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
538 unsigned long r;
539 _BitScanReverse64 (&r, x);
540 return (int)r;
541#else
481 int r = 0; 542 int r = 0;
482 543
483 if (x >> 32) { x >>= 32; r += 32; } 544 if (x >> 32) { x >>= 32; r += 32; }
484 545
485 return r + ecb_ld32 (x); 546 return r + ecb_ld32 (x);
547#endif
486 } 548 }
487#endif 549#endif
488 550
489ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x); 551ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
490ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); } 552ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
… …
547ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); } 609ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
548ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); } 610ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
549ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); } 611ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
550 612
551#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64)) 613#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
614 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
615 #define ecb_bswap16(x) __builtin_bswap16 (x)
616 #else
552 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16) 617 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
618 #endif
553 #define ecb_bswap32(x) __builtin_bswap32 (x) 619 #define ecb_bswap32(x) __builtin_bswap32 (x)
554 #define ecb_bswap64(x) __builtin_bswap64 (x) 620 #define ecb_bswap64(x) __builtin_bswap64 (x)
621#elif _MSC_VER
622 #include <stdlib.h>
623 #define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
624 #define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
625 #define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
555#else 626#else
556 ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x); 627 ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
557 ecb_function_ ecb_const uint16_t 628 ecb_function_ ecb_const uint16_t
558 ecb_bswap16 (uint16_t x) 629 ecb_bswap16 (uint16_t x)
559 { 630 {
… …
584#endif 655#endif
585 656
586/* try to tell the compiler that some condition is definitely true */ 657/* try to tell the compiler that some condition is definitely true */
587#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0 658#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
588 659
589ecb_inline ecb_const unsigned char ecb_byteorder_helper (void); 660ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
590ecb_inline ecb_const unsigned char 661ecb_inline ecb_const uint32_t
591ecb_byteorder_helper (void) 662ecb_byteorder_helper (void)
592{ 663{
593 /* the union code still generates code under pressure in gcc, */ 664 /* the union code still generates code under pressure in gcc, */
594 /* but less than using pointers, and always seems to */ 665 /* but less than using pointers, and always seems to */
595 /* successfully return a constant. */ 666 /* successfully return a constant. */
596 /* the reason why we have this horrible preprocessor mess */ 667 /* the reason why we have this horrible preprocessor mess */
597 /* is to avoid it in all cases, at least on common architectures */ 668 /* is to avoid it in all cases, at least on common architectures */
598 /* or when using a recent enough gcc version (>= 4.6) */ 669 /* or when using a recent enough gcc version (>= 4.6) */
599#if ((__i386 || __i386__) && !__VOS__) || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64
600 return 0x44;
601#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 670#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
671 || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
672 #define ECB_LITTLE_ENDIAN 1
602 return 0x44; 673 return 0x44332211;
603#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 674#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
675 || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
676 #define ECB_BIG_ENDIAN 1
604 return 0x11; 677 return 0x11223344;
605#else 678#else
606 union 679 union
607 { 680 {
681 uint8_t c[4];
608 uint32_t i; 682 uint32_t u;
609 uint8_t c;
610 } u = { 0x11223344 }; 683 } u = { 0x11, 0x22, 0x33, 0x44 };
611 return u.c; 684 return u.u;
612#endif 685#endif
613} 686}
614 687
615ecb_inline ecb_const ecb_bool ecb_big_endian (void); 688ecb_inline ecb_const ecb_bool ecb_big_endian (void);
616ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; } 689ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
617ecb_inline ecb_const ecb_bool ecb_little_endian (void); 690ecb_inline ecb_const ecb_bool ecb_little_endian (void);
618ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; } 691ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
692
693/*****************************************************************************/
694/* unaligned load/store */
695
696ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
697ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
698ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
699
700ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
701ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
702ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
703
704ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
705ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
706ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
707
708ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
709ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
710ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
711
712ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
713ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
714ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
715
716ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
717ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
718ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
719
720ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
721ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
722ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
723
724ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
725ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
726ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
727
728ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
729ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
730ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
731
732ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
733ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
734ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
735
736#ifdef __cplusplus
737
738inline uint8_t ecb_bswap (uint8_t v) { return v; }
739inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
740inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
741inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
742
743template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
744template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
745template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
746template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
747template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
748template<typename T> inline T ecb_peek_u (const void *ptr) { T v; std::memcpy (&v, ptr, sizeof (v)); return v; }
749template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
750template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
751
752template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
753template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
754template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
755template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
756template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
757template<typename T> inline void ecb_poke_u (void *ptr, T v) { std::memcpy (ptr, &v, sizeof (v)); }
758template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
759template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
760
761#endif
762
763/*****************************************************************************/
619 764
620#if ECB_GCC_VERSION(3,0) || ECB_C99 765#if ECB_GCC_VERSION(3,0) || ECB_C99
621 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0)) 766 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
622#else 767#else
623 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n))) 768 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
… …
647 return N; 792 return N;
648 } 793 }
649#else 794#else
650 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 795 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
651#endif 796#endif
797
798/*****************************************************************************/
799
800ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
801ecb_function_ ecb_const uint32_t
802ecb_binary16_to_binary32 (uint32_t x)
803{
804 unsigned int s = (x & 0x8000) << (31 - 15);
805 int e = (x >> 10) & 0x001f;
806 unsigned int m = x & 0x03ff;
807
808 if (ecb_expect_false (e == 31))
809 /* infinity or NaN */
810 e = 255 - (127 - 15);
811 else if (ecb_expect_false (!e))
812 {
813 if (ecb_expect_true (!m))
814 /* zero, handled by code below by forcing e to 0 */
815 e = 0 - (127 - 15);
816 else
817 {
818 /* subnormal, renormalise */
819 unsigned int s = 10 - ecb_ld32 (m);
820
821 m = (m << s) & 0x3ff; /* mask implicit bit */
822 e -= s - 1;
823 }
824 }
825
826 /* e and m now are normalised, or zero, (or inf or nan) */
827 e += 127 - 15;
828
829 return s | (e << 23) | (m << (23 - 10));
830}
831
832ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
833ecb_function_ ecb_const uint16_t
834ecb_binary32_to_binary16 (uint32_t x)
835{
836 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
837 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
838 unsigned int m = x & 0x007fffff;
839
840 x &= 0x7fffffff;
841
842 /* if it's within range of binary16 normals, use fast path */
843 if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
844 {
845 /* mantissa round-to-even */
846 m += 0x00000fff + ((m >> (23 - 10)) & 1);
847
848 /* handle overflow */
849 if (ecb_expect_false (m >= 0x00800000))
850 {
851 m >>= 1;
852 e += 1;
853 }
854
855 return s | (e << 10) | (m >> (23 - 10));
856 }
857
858 /* handle large numbers and infinity */
859 if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
860 return s | 0x7c00;
861
862 /* handle zero, subnormals and small numbers */
863 if (ecb_expect_true (x < 0x38800000))
864 {
865 /* zero */
866 if (ecb_expect_true (!x))
867 return s;
868
869 /* handle subnormals */
870
871 /* too small, will be zero */
872 if (e < (14 - 24)) /* might not be sharp, but is good enough */
873 return s;
874
875 m |= 0x00800000; /* make implicit bit explicit */
876
877 /* very tricky - we need to round to the nearest e (+10) bit value */
878 {
879 unsigned int bits = 14 - e;
880 unsigned int half = (1 << (bits - 1)) - 1;
881 unsigned int even = (m >> bits) & 1;
882
883 /* if this overflows, we will end up with a normalised number */
884 m = (m + half + even) >> bits;
885 }
886
887 return s | m;
888 }
889
890 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
891 m >>= 13;
892
893 return s | 0x7c00 | m | !m;
894}
652 895
653/*******************************************************************************/ 896/*******************************************************************************/
654/* floating point stuff, can be disabled by defining ECB_NO_LIBM */ 897/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
655 898
656/* basically, everything uses "ieee pure-endian" floating point numbers */ 899/* basically, everything uses "ieee pure-endian" floating point numbers */
… …
693 #define ECB_NAN ECB_INFINITY 936 #define ECB_NAN ECB_INFINITY
694 #endif 937 #endif
695 938
696 #if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L 939 #if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
697 #define ecb_ldexpf(x,e) ldexpf ((x), (e)) 940 #define ecb_ldexpf(x,e) ldexpf ((x), (e))
941 #define ecb_frexpf(x,e) frexpf ((x), (e))
698 #else 942 #else
699 #define ecb_ldexpf(x,e) (float) ldexp ((float) (x), (e)) 943 #define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
944 #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
700 #endif 945 #endif
701
702 /* converts an ieee half/binary16 to a float */
703 ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
704 ecb_function_ ecb_const float
705 ecb_binary16_to_float (uint16_t x)
706 {
707 int e = (x >> 10) & 0x1f;
708 int m = x & 0x3ff;
709 float r;
710
711 if (!e ) r = ecb_ldexpf (m , -24);
712 else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
713 else if (m ) r = ECB_NAN;
714 else r = ECB_INFINITY;
715
716 return x & 0x8000 ? -r : r;
717 }
718 946
719 /* convert a float to ieee single/binary32 */ 947 /* convert a float to ieee single/binary32 */
720 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x); 948 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
721 ecb_function_ ecb_const uint32_t 949 ecb_function_ ecb_const uint32_t
722 ecb_float_to_binary32 (float x) 950 ecb_float_to_binary32 (float x)
… …
733 if (x == 0e0f ) return 0x00000000U; 961 if (x == 0e0f ) return 0x00000000U;
734 if (x > +3.40282346638528860e+38f) return 0x7f800000U; 962 if (x > +3.40282346638528860e+38f) return 0x7f800000U;
735 if (x < -3.40282346638528860e+38f) return 0xff800000U; 963 if (x < -3.40282346638528860e+38f) return 0xff800000U;
736 if (x != x ) return 0x7fbfffffU; 964 if (x != x ) return 0x7fbfffffU;
737 965
738 m = frexpf (x, &e) * 0x1000000U; 966 m = ecb_frexpf (x, &e) * 0x1000000U;
739 967
740 r = m & 0x80000000U; 968 r = m & 0x80000000U;
741 969
742 if (r) 970 if (r)
743 m = -m; 971 m = -m;
… …
854 #endif 1082 #endif
855 1083
856 return r; 1084 return r;
857 } 1085 }
858 1086
859#endif 1087 /* convert a float to ieee half/binary16 */
1088 ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
1089 ecb_function_ ecb_const uint16_t
1090 ecb_float_to_binary16 (float x)
1091 {
1092 return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
1093 }
860 1094
861#endif 1095 /* convert an ieee half/binary16 to float */
1096 ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
1097 ecb_function_ ecb_const float
1098 ecb_binary16_to_float (uint16_t x)
1099 {
1100 return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
1101 }
862 1102
1103#endif
1104
1105#endif
1106

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines