[ViewVC] Diff of: cvs/libecb/ecb.h

Comparing libecb/ecb.h (file contents):
Revision 1.79 by root, Sat Feb 4 17:57:47 2012 UTC vs.
Revision 1.127 by root, Sun Jan 5 15:54:09 2014 UTC

…		…
1	/*	1	/*
2	* libecb - http://software.schmorp.de/pkg/libecb	2	* libecb - http://software.schmorp.de/pkg/libecb
3	*	3	*
4	* Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>	4	* Copyright (©) 2009-2013 Marc Alexander Lehmann <libecb@schmorp.de>
5	* Copyright (©) 2011 Emanuele Giaquinta	5	* Copyright (©) 2011 Emanuele Giaquinta
6	* All rights reserved.	6	* All rights reserved.
7	*	7	*
8	* Redistribution and use in source and binary forms, with or without modifica-	8	* Redistribution and use in source and binary forms, with or without modifica-
9	* tion, are permitted provided that the following conditions are met:	9	* tion, are permitted provided that the following conditions are met:
28	*/	28	*/
29		29
30	#ifndef ECB_H	30	#ifndef ECB_H
31	#define ECB_H	31	#define ECB_H
32		32
		33	/* 16 bits major, 16 bits minor */
		34	#define ECB_VERSION 0x00010003
		35
33	#ifdef _WIN32	36	#ifdef _WIN32
34	typedef signed char int8_t;	37	typedef signed char int8_t;
35	typedef unsigned char uint8_t;	38	typedef unsigned char uint8_t;
36	typedef signed short int16_t;	39	typedef signed short int16_t;
37	typedef unsigned short uint16_t;	40	typedef unsigned short uint16_t;
…		…
42	typedef unsigned long long uint64_t;	45	typedef unsigned long long uint64_t;
43	#else /* _MSC_VER \|\| __BORLANDC__ */	46	#else /* _MSC_VER \|\| __BORLANDC__ */
44	typedef signed __int64 int64_t;	47	typedef signed __int64 int64_t;
45	typedef unsigned __int64 uint64_t;	48	typedef unsigned __int64 uint64_t;
46	#endif	49	#endif
		50	#ifdef _WIN64
		51	#define ECB_PTRSIZE 8
		52	typedef uint64_t uintptr_t;
		53	typedef int64_t intptr_t;
		54	#else
		55	#define ECB_PTRSIZE 4
		56	typedef uint32_t uintptr_t;
		57	typedef int32_t intptr_t;
		58	#endif
47	#else	59	#else
48	#include <inttypes.h>	60	#include <inttypes.h>
		61	#if UINTMAX_MAX > 0xffffffffU
		62	#define ECB_PTRSIZE 8
		63	#else
		64	#define ECB_PTRSIZE 4
		65	#endif
		66	#endif
		67
		68	/* work around x32 idiocy by defining proper macros */
		69	#if __amd64 \|\| __x86_64 \|\| _M_AMD64 \|\| _M_X64
		70	#if _ILP32
		71	#define ECB_AMD64_X32 1
		72	#else
		73	#define ECB_AMD64 1
		74	#endif
49	#endif	75	#endif
50		76
51	/* many compilers define _GNUC_ to some versions but then only implement	77	/* many compilers define _GNUC_ to some versions but then only implement
52	* what their idiot authors think are the "more important" extensions,	78	* what their idiot authors think are the "more important" extensions,
53	* causing enormous grief in return for some better fake benchmark numbers.	79	* causing enormous grief in return for some better fake benchmark numbers.
54	* or so.	80	* or so.
55	* we try to detect these and simply assume they are not gcc - if they have	81	* we try to detect these and simply assume they are not gcc - if they have
56	* an issue with that they should have done it right in the first place.	82	* an issue with that they should have done it right in the first place.
57	*/	83	*/
58	#ifndef ECB_GCC_VERSION	84	#ifndef ECB_GCC_VERSION
59	#if !defined(__GNUC_MINOR__) \|\| defined(__INTEL_COMPILER) \|\| defined(__SUNPRO_C) \|\| defined(__SUNPRO_CC) \|\| defined(__llvm__) \|\| defined(__clang__)	85	#if !defined __GNUC_MINOR__ \|\| defined __INTEL_COMPILER \|\| defined __SUNPRO_C \|\| defined __SUNPRO_CC \|\| defined __llvm__ \|\| defined __clang__
60	#define ECB_GCC_VERSION(major,minor) 0	86	#define ECB_GCC_VERSION(major,minor) 0
61	#else	87	#else
62	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) \|\| (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))	88	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) \|\| (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
63	#endif	89	#endif
64	#endif	90	#endif
65		91
		92	#define ECB_CPP (__cplusplus+0)
		93	#define ECB_CPP11 (__cplusplus >= 201103L)
		94
		95	#if ECB_CPP
		96	#define ECB_C 0
		97	#define ECB_STDC_VERSION 0
		98	#else
		99	#define ECB_C 1
		100	#define ECB_STDC_VERSION __STDC_VERSION__
		101	#endif
		102
		103	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
		104	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
		105
		106	#if ECB_CPP
		107	#define ECB_EXTERN_C extern "C"
		108	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
		109	#define ECB_EXTERN_C_END }
		110	#else
		111	#define ECB_EXTERN_C extern
		112	#define ECB_EXTERN_C_BEG
		113	#define ECB_EXTERN_C_END
		114	#endif
		115
66	/*****************************************************************************/	116	/*****************************************************************************/
67		117
68	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */	118	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
69	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */	119	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
70		120
71	#if ECB_NO_THREADS	121	#if ECB_NO_THREADS
72	# define ECB_NO_SMP 1	122	#define ECB_NO_SMP 1
73	#endif	123	#endif
74		124
75	#if ECB_NO_THREADS \|\| ECB_NO_SMP	125	#if ECB_NO_SMP
76	#define ECB_MEMORY_FENCE do { } while (0)	126	#define ECB_MEMORY_FENCE do { } while (0)
77	#endif	127	#endif
78		128
79	#ifndef ECB_MEMORY_FENCE	129	#ifndef ECB_MEMORY_FENCE
80	#if ECB_GCC_VERSION(2,5) \|\| defined(__INTEL_COMPILER) \|\| (__llvm__ && __GNUC__) \|\| __SUNPRO_C >= 0x5110 \|\| __SUNPRO_CC >= 0x5110	130	#if ECB_GCC_VERSION(2,5) \|\| defined __INTEL_COMPILER \|\| (__llvm__ && __GNUC__) \|\| __SUNPRO_C >= 0x5110 \|\| __SUNPRO_CC >= 0x5110
81	#if __i386 \|\| __i386__	131	#if __i386 \|\| __i386__
82	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	132	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
83	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */	133	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
84	#define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */	134	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
85	#elif __amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__	135	#elif __amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__
86	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")	136	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
87	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")	137	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
88	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */	138	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
89	#elif __powerpc__ \|\| __ppc__ \|\| __powerpc64__ \|\| __ppc64__	139	#elif __powerpc__ \|\| __ppc__ \|\| __powerpc64__ \|\| __ppc64__
90	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	140	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
91	#elif defined(__ARM_ARCH_6__ ) \|\| defined(__ARM_ARCH_6J__ ) \	141	#elif defined __ARM_ARCH_6__ \|\| defined __ARM_ARCH_6J__ \
92	\|\| defined(__ARM_ARCH_6K__) \|\| defined(__ARM_ARCH_6ZK__)	142	\|\| defined __ARM_ARCH_6K__ \|\| defined __ARM_ARCH_6ZK__
93	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")	143	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
94	#elif defined(__ARM_ARCH_7__ ) \|\| defined(__ARM_ARCH_7A__ ) \	144	#elif defined __ARM_ARCH_7__ \|\| defined __ARM_ARCH_7A__ \
95	\|\| defined(__ARM_ARCH_7M__) \|\| defined(__ARM_ARCH_7R__ )	145	\|\| defined __ARM_ARCH_7M__ \|\| defined __ARM_ARCH_7R__
96	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")	146	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
97	#elif __sparc \|\| __sparc__	147	#elif (__sparc \|\| __sparc__) && !__sparcv8
98	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore \| #LoadLoad \| #StoreStore \| #StoreLoad \| " : : : "memory")	148	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore \| #LoadLoad \| #StoreStore \| #StoreLoad" : : : "memory")
99	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore \| #LoadLoad" : : : "memory")	149	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore \| #LoadLoad" : : : "memory")
100	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore \| #StoreStore")	150	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore \| #StoreStore")
101	#elif defined(__s390__) \|\| defined(__s390x__)	151	#elif defined __s390__ \|\| defined __s390x__
102	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")	152	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
		153	#elif defined __mips__
		154	/* GNU/Linux emulates sync on mips1 architectures, so we force its use */
		155	/* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
		156	#define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
		157	#elif defined __alpha__
		158	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
		159	#elif defined __hppa__
		160	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		161	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
		162	#elif defined __ia64__
		163	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
		164	#elif defined __m68k__
		165	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		166	#elif defined __m88k__
		167	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
		168	#elif defined __sh__
		169	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
103	#endif	170	#endif
104	#endif	171	#endif
105	#endif	172	#endif
106		173
107	#ifndef ECB_MEMORY_FENCE	174	#ifndef ECB_MEMORY_FENCE
		175	#if ECB_GCC_VERSION(4,7)
		176	/* see comment below (stdatomic.h) about the C11 memory model. */
		177	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
		178
		179	/* The __has_feature syntax from clang is so misdesigned that we cannot use it
		180	* without risking compile time errors with other compilers. We could
		181	* define our own ecb_clang_has_feature, but I just can't be bothered to work
		182	* around this shit time and again.
		183	* #elif defined __clang && __has_feature (cxx_atomic)
		184	* // see comment below (stdatomic.h) about the C11 memory model.
		185	* #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
		186	*/
		187
108	#if ECB_GCC_VERSION(4,4) \|\| defined(__INTEL_COMPILER) \|\| defined(__clang__)	188	#elif ECB_GCC_VERSION(4,4) \|\| defined __INTEL_COMPILER \|\| defined __clang__
109	#define ECB_MEMORY_FENCE __sync_synchronize ()	189	#define ECB_MEMORY_FENCE __sync_synchronize ()
110	/#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) /	190	#elif _MSC_VER >= 1500 /* VC++ 2008 */
111	/#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) /	191	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
		192	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
		193	#define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
		194	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
		195	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
112	#elif _MSC_VER >= 1400 /* VC++ 2005 */	196	#elif _MSC_VER >= 1400 /* VC++ 2005 */
113	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)	197	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
114	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()	198	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
115	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */	199	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
116	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()	200	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
117	#elif defined(_WIN32)	201	#elif defined _WIN32
118	#include <WinNT.h>	202	#include <WinNT.h>
119	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */	203	#define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
120	#elif __SUNPRO_C >= 0x5110 \|\| __SUNPRO_CC >= 0x5110	204	#elif __SUNPRO_C >= 0x5110 \|\| __SUNPRO_CC >= 0x5110
121	#include <mbarrier.h>	205	#include <mbarrier.h>
122	#define ECB_MEMORY_FENCE __machine_rw_barrier ()	206	#define ECB_MEMORY_FENCE __machine_rw_barrier ()
123	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()	207	#define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()
124	#define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()	208	#define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()
		209	#elif __xlC__
		210	#define ECB_MEMORY_FENCE __sync ()
		211	#endif
		212	#endif
		213
		214	#ifndef ECB_MEMORY_FENCE
		215	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
		216	/* we assume that these memory fences work on all variables/all memory accesses, */
		217	/* not just C11 atomics and atomic accesses */
		218	#include <stdatomic.h>
		219	/* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
		220	/* any fence other than seq_cst, which isn't very efficient for us. */
		221	/* Why that is, we don't know - either the C11 memory model is quite useless */
		222	/* for most usages, or gcc and clang have a bug */
		223	/* I currently lean towards the latter, and inefficiently implement */
		224	/* all three of ecb's fences as a seq_cst fence */
		225	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
125	#endif	226	#endif
126	#endif	227	#endif
127		228
128	#ifndef ECB_MEMORY_FENCE	229	#ifndef ECB_MEMORY_FENCE
129	#if !ECB_AVOID_PTHREADS	230	#if !ECB_AVOID_PTHREADS
…		…
141	static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;	242	static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
142	#define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)	243	#define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
143	#endif	244	#endif
144	#endif	245	#endif
145		246
146	#if !defined(ECB_MEMORY_FENCE_ACQUIRE) && defined(ECB_MEMORY_FENCE)	247	#if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
147	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE	248	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
148	#endif	249	#endif
149		250
150	#if !defined(ECB_MEMORY_FENCE_RELEASE) && defined(ECB_MEMORY_FENCE)	251	#if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
151	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	252	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
152	#endif	253	#endif
153		254
154	/*****************************************************************************/	255	/*****************************************************************************/
155
156	#define ECB_C99 (__STDC_VERSION__ >= 199901L)
157		256
158	#if __cplusplus	257	#if __cplusplus
159	#define ecb_inline static inline	258	#define ecb_inline static inline
160	#elif ECB_GCC_VERSION(2,5)	259	#elif ECB_GCC_VERSION(2,5)
161	#define ecb_inline static __inline__	260	#define ecb_inline static __inline__
…		…
187	#define ecb_is_constant(expr) __builtin_constant_p (expr)	286	#define ecb_is_constant(expr) __builtin_constant_p (expr)
188	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))	287	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
189	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)	288	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
190	#else	289	#else
191	#define ecb_attribute(attrlist)	290	#define ecb_attribute(attrlist)
		291
		292	/* possible C11 impl for integral types
		293	typedef struct ecb_is_constant_struct ecb_is_constant_struct;
		294	#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct )0 : (void )((expr) - (expr)), ecb_is_constant_struct : 0, default: 1)) /
		295
192	#define ecb_is_constant(expr) 0	296	#define ecb_is_constant(expr) 0
193	#define ecb_expect(expr,value) (expr)	297	#define ecb_expect(expr,value) (expr)
194	#define ecb_prefetch(addr,rw,locality)	298	#define ecb_prefetch(addr,rw,locality)
195	#endif	299	#endif
196		300
…		…
200	#elif ECB_GCC_VERSION(3,0)	304	#elif ECB_GCC_VERSION(3,0)
201	#define ecb_decltype(x) __typeof(x)	305	#define ecb_decltype(x) __typeof(x)
202	#endif	306	#endif
203		307
204	#define ecb_noinline ecb_attribute ((__noinline__))	308	#define ecb_noinline ecb_attribute ((__noinline__))
205	#define ecb_noreturn ecb_attribute ((__noreturn__))
206	#define ecb_unused ecb_attribute ((__unused__))	309	#define ecb_unused ecb_attribute ((__unused__))
207	#define ecb_const ecb_attribute ((__const__))	310	#define ecb_const ecb_attribute ((__const__))
208	#define ecb_pure ecb_attribute ((__pure__))	311	#define ecb_pure ecb_attribute ((__pure__))
		312
		313	#if ECB_C11
		314	#define ecb_noreturn _Noreturn
		315	#else
		316	#define ecb_noreturn ecb_attribute ((__noreturn__))
		317	#endif
209		318
210	#if ECB_GCC_VERSION(4,3)	319	#if ECB_GCC_VERSION(4,3)
211	#define ecb_artificial ecb_attribute ((__artificial__))	320	#define ecb_artificial ecb_attribute ((__artificial__))
212	#define ecb_hot ecb_attribute ((__hot__))	321	#define ecb_hot ecb_attribute ((__hot__))
213	#define ecb_cold ecb_attribute ((__cold__))	322	#define ecb_cold ecb_attribute ((__cold__))
…		…
304		413
305	return r + ecb_ld32 (x);	414	return r + ecb_ld32 (x);
306	}	415	}
307	#endif	416	#endif
308		417
		418	ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
		419	ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
		420	ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
		421	ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
		422
309	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;	423	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
310	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)	424	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
311	{	425	{
312	return ( (x * 0x0802U & 0x22110U)	426	return ( (x * 0x0802U & 0x22110U)
313	\| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;	427	\| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
…		…
397	ecb_inline void ecb_unreachable (void) ecb_noreturn;	511	ecb_inline void ecb_unreachable (void) ecb_noreturn;
398	ecb_inline void ecb_unreachable (void) { }	512	ecb_inline void ecb_unreachable (void) { }
399	#endif	513	#endif
400		514
401	/* try to tell the compiler that some condition is definitely true */	515	/* try to tell the compiler that some condition is definitely true */
402	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)	516	#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
403		517
404	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;	518	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
405	ecb_inline unsigned char	519	ecb_inline unsigned char
406	ecb_byteorder_helper (void)	520	ecb_byteorder_helper (void)
407	{	521	{
408	const uint32_t u = 0x11223344;	522	/* the union code still generates code under pressure in gcc, */
409	return (unsigned char )&u;	523	/* but less than using pointers, and always seems to */
		524	/* successfully return a constant. */
		525	/* the reason why we have this horrible preprocessor mess */
		526	/* is to avoid it in all cases, at least on common architectures */
		527	/* or when using a recent enough gcc version (>= 4.6) */
		528	#if __i386 \|\| __i386__ \|\| _M_X86 \|\| __amd64 \|\| __amd64__ \|\| _M_X64
		529	return 0x44;
		530	#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
		531	return 0x44;
		532	#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
		533	return 0x11;
		534	#else
		535	union
		536	{
		537	uint32_t i;
		538	uint8_t c;
		539	} u = { 0x11223344 };
		540	return u.c;
		541	#endif
410	}	542	}
411		543
412	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;	544	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
413	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }	545	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
414	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;	546	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
…		…
445	}	577	}
446	#else	578	#else
447	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	579	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
448	#endif	580	#endif
449		581
		582	/*******************************************************************************/
		583	/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
		584
		585	/* basically, everything uses "ieee pure-endian" floating point numbers */
		586	/* the only noteworthy exception is ancient armle, which uses order 43218765 */
		587	#if 0 \
		588	\|\| __i386 \|\| __i386__ \
		589	\|\| __amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__ \
		590	\|\| __powerpc__ \|\| __ppc__ \|\| __powerpc64__ \|\| __ppc64__ \
		591	\|\| defined __arm__ && defined __ARM_EABI__ \
		592	\|\| defined __s390__ \|\| defined __s390x__ \
		593	\|\| defined __mips__ \
		594	\|\| defined __alpha__ \
		595	\|\| defined __hppa__ \
		596	\|\| defined __ia64__ \
		597	\|\| defined __m68k__ \
		598	\|\| defined __m88k__ \
		599	\|\| defined __sh__ \
		600	\|\| defined _M_IX86 \|\| defined _M_AMD64 \|\| defined _M_IA64
		601	#define ECB_STDFP 1
		602	#include <string.h> /* for memcpy */
		603	#else
		604	#define ECB_STDFP 0
		605	#endif
		606
		607	#ifndef ECB_NO_LIBM
		608
		609	#include <math.h> /* for frexp, ldexp, INFINITY, NAN */
		610
		611	/* only the oldest of old doesn't have this one. solaris. */
		612	#ifdef INFINITY
		613	#define ECB_INFINITY INFINITY
		614	#else
		615	#define ECB_INFINITY HUGE_VAL
450	#endif	616	#endif
451		617
		618	#ifdef NAN
		619	#define ECB_NAN NAN
		620	#else
		621	#define ECB_NAN ECB_INFINITY
		622	#endif
		623
		624	/* converts an ieee half/binary16 to a float */
		625	ecb_function_ float ecb_binary16_to_float (uint16_t x) ecb_const;
		626	ecb_function_ float
		627	ecb_binary16_to_float (uint16_t x)
		628	{
		629	int e = (x >> 10) & 0x1f;
		630	int m = x & 0x3ff;
		631	float r;
		632
		633	if (!e ) r = ldexpf (m , -24);
		634	else if (e != 31) r = ldexpf (m + 0x400, e - 25);
		635	else if (m ) r = ECB_NAN;
		636	else r = ECB_INFINITY;
		637
		638	return x & 0x8000 ? -r : r;
		639	}
		640
		641	/* convert a float to ieee single/binary32 */
		642	ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
		643	ecb_function_ uint32_t
		644	ecb_float_to_binary32 (float x)
		645	{
		646	uint32_t r;
		647
		648	#if ECB_STDFP
		649	memcpy (&r, &x, 4);
		650	#else
		651	/* slow emulation, works for anything but -0 */
		652	uint32_t m;
		653	int e;
		654
		655	if (x == 0e0f ) return 0x00000000U;
		656	if (x > +3.40282346638528860e+38f) return 0x7f800000U;
		657	if (x < -3.40282346638528860e+38f) return 0xff800000U;
		658	if (x != x ) return 0x7fbfffffU;
		659
		660	m = frexpf (x, &e) * 0x1000000U;
		661
		662	r = m & 0x80000000U;
		663
		664	if (r)
		665	m = -m;
		666
		667	if (e <= -126)
		668	{
		669	m &= 0xffffffU;
		670	m >>= (-125 - e);
		671	e = -126;
		672	}
		673
		674	r \|= (e + 126) << 23;
		675	r \|= m & 0x7fffffU;
		676	#endif
		677
		678	return r;
		679	}
		680
		681	/* converts an ieee single/binary32 to a float */
		682	ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
		683	ecb_function_ float
		684	ecb_binary32_to_float (uint32_t x)
		685	{
		686	float r;
		687
		688	#if ECB_STDFP
		689	memcpy (&r, &x, 4);
		690	#else
		691	/* emulation, only works for normals and subnormals and +0 */
		692	int neg = x >> 31;
		693	int e = (x >> 23) & 0xffU;
		694
		695	x &= 0x7fffffU;
		696
		697	if (e)
		698	x \|= 0x800000U;
		699	else
		700	e = 1;
		701
		702	/* we distrust ldexpf a bit and do the 2*-24 scaling by an extra multiply /
		703	r = ldexpf (x * (0.5f / 0x800000U), e - 126);
		704
		705	r = neg ? -r : r;
		706	#endif
		707
		708	return r;
		709	}
		710
		711	/* convert a double to ieee double/binary64 */
		712	ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
		713	ecb_function_ uint64_t
		714	ecb_double_to_binary64 (double x)
		715	{
		716	uint64_t r;
		717
		718	#if ECB_STDFP
		719	memcpy (&r, &x, 8);
		720	#else
		721	/* slow emulation, works for anything but -0 */
		722	uint64_t m;
		723	int e;
		724
		725	if (x == 0e0 ) return 0x0000000000000000U;
		726	if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
		727	if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
		728	if (x != x ) return 0X7ff7ffffffffffffU;
		729
		730	m = frexp (x, &e) * 0x20000000000000U;
		731
		732	r = m & 0x8000000000000000;;
		733
		734	if (r)
		735	m = -m;
		736
		737	if (e <= -1022)
		738	{
		739	m &= 0x1fffffffffffffU;
		740	m >>= (-1021 - e);
		741	e = -1022;
		742	}
		743
		744	r \|= ((uint64_t)(e + 1022)) << 52;
		745	r \|= m & 0xfffffffffffffU;
		746	#endif
		747
		748	return r;
		749	}
		750
		751	/* converts an ieee double/binary64 to a double */
		752	ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
		753	ecb_function_ double
		754	ecb_binary64_to_double (uint64_t x)
		755	{
		756	double r;
		757
		758	#if ECB_STDFP
		759	memcpy (&r, &x, 8);
		760	#else
		761	/* emulation, only works for normals and subnormals and +0 */
		762	int neg = x >> 63;
		763	int e = (x >> 52) & 0x7ffU;
		764
		765	x &= 0xfffffffffffffU;
		766
		767	if (e)
		768	x \|= 0x10000000000000U;
		769	else
		770	e = 1;
		771
		772	/* we distrust ldexp a bit and do the 2*-53 scaling by an extra multiply /
		773	r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
		774
		775	r = neg ? -r : r;
		776	#endif
		777
		778	return r;
		779	}
		780
		781	#endif
		782
		783	#endif
		784

Diff Legend

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

Comparing libecb/ecb.h (file contents): Revision 1.79 by root, Sat Feb 4 17:57:47 2012 UTC vs. Revision 1.127 by root, Sun Jan 5 15:54:09 2014 UTC

Diff Legend

Comparing libecb/ecb.h (file contents):
Revision 1.79 by root, Sat Feb 4 17:57:47 2012 UTC vs.
Revision 1.127 by root, Sun Jan 5 15:54:09 2014 UTC