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

Comparing libeio/ecb.h (file contents):
Revision 1.13 by root, Sat Jun 2 20:13:26 2012 UTC vs.
Revision 1.17 by root, Fri Dec 28 07:33:41 2012 UTC

…		…
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 */	33	/* 16 bits major, 16 bits minor */
34	#define ECB_VERSION 0x00010001	34	#define ECB_VERSION 0x00010003
35		35
36	#ifdef _WIN32	36	#ifdef _WIN32
37	typedef signed char int8_t;	37	typedef signed char int8_t;
38	typedef unsigned char uint8_t;	38	typedef unsigned char uint8_t;
39	typedef signed short int16_t;	39	typedef signed short int16_t;
…		…
54	#else	54	#else
55	#define ECB_PTRSIZE 4	55	#define ECB_PTRSIZE 4
56	typedef uint32_t uintptr_t;	56	typedef uint32_t uintptr_t;
57	typedef int32_t intptr_t;	57	typedef int32_t intptr_t;
58	#endif	58	#endif
59	typedef intptr_t ptrdiff_t;
60	#else	59	#else
61	#include <inttypes.h>	60	#include <inttypes.h>
62	#if UINTMAX_MAX > 0xffffffffU	61	#if UINTMAX_MAX > 0xffffffffU
63	#define ECB_PTRSIZE 8	62	#define ECB_PTRSIZE 8
64	#else	63	#else
65	#define ECB_PTRSIZE 4	64	#define ECB_PTRSIZE 4
		65	#endif
		66	#endif
		67
		68	/* work around x32 idiocy by defining proper macros */
		69	#if __x86_64 \|\| _M_AMD64
		70	#if __ILP32
		71	#define ECB_AMD64_X32 1
		72	#else
		73	#define ECB_AMD64 1
66	#endif	74	#endif
67	#endif	75	#endif
68		76
69	/* many compilers define _GNUC_ to some versions but then only implement	77	/* many compilers define _GNUC_ to some versions but then only implement
70	* what their idiot authors think are the "more important" extensions,	78	* what their idiot authors think are the "more important" extensions,
…		…
84	#define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */	92	#define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */
85	#define ECB_C99 (__STDC_VERSION__ >= 199901L)	93	#define ECB_C99 (__STDC_VERSION__ >= 199901L)
86	#define ECB_C11 (__STDC_VERSION__ >= 201112L)	94	#define ECB_C11 (__STDC_VERSION__ >= 201112L)
87	#define ECB_CPP (__cplusplus+0)	95	#define ECB_CPP (__cplusplus+0)
88	#define ECB_CPP11 (__cplusplus >= 201103L)	96	#define ECB_CPP11 (__cplusplus >= 201103L)
		97
		98	#if ECB_CPP
		99	#define ECB_EXTERN_C extern "C"
		100	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
		101	#define ECB_EXTERN_C_END }
		102	#else
		103	#define ECB_EXTERN_C extern
		104	#define ECB_EXTERN_C_BEG
		105	#define ECB_EXTERN_C_END
		106	#endif
89		107
90	/*****************************************************************************/	108	/*****************************************************************************/
91		109
92	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */	110	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
93	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */	111	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
…		…
139		157
140	#ifndef ECB_MEMORY_FENCE	158	#ifndef ECB_MEMORY_FENCE
141	#if ECB_GCC_VERSION(4,7)	159	#if ECB_GCC_VERSION(4,7)
142	/* see comment below (stdatomic.h) about the C11 memory model. */	160	/* see comment below (stdatomic.h) about the C11 memory model. */
143	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)	161	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
		162
		163	/* The __has_feature syntax from clang is so misdesigned that we cannot use it
		164	* without risking compile time errors with other compilers. We could
		165	* define our own ecb_clang_has_feature, but I just can't be bothered to work
		166	* around this shit time and again.
144	#elif defined __clang && __has_feature (cxx_atomic)	167	* #elif defined __clang && __has_feature (cxx_atomic)
145	/* see comment below (stdatomic.h) about the C11 memory model. */	168	* // see comment below (stdatomic.h) about the C11 memory model.
146	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)	169	* #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
		170	*/
		171
147	#elif ECB_GCC_VERSION(4,4) \|\| defined __INTEL_COMPILER \|\| defined __clang__	172	#elif ECB_GCC_VERSION(4,4) \|\| defined __INTEL_COMPILER \|\| defined __clang__
148	#define ECB_MEMORY_FENCE __sync_synchronize ()	173	#define ECB_MEMORY_FENCE __sync_synchronize ()
149	#elif _MSC_VER >= 1400 /* VC++ 2005 */	174	#elif _MSC_VER >= 1400 /* VC++ 2005 */
150	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)	175	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
151	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()	176	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
…		…
459	ecb_inline void ecb_unreachable (void) ecb_noreturn;	484	ecb_inline void ecb_unreachable (void) ecb_noreturn;
460	ecb_inline void ecb_unreachable (void) { }	485	ecb_inline void ecb_unreachable (void) { }
461	#endif	486	#endif
462		487
463	/* try to tell the compiler that some condition is definitely true */	488	/* try to tell the compiler that some condition is definitely true */
464	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)	489	#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
465		490
466	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;	491	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
467	ecb_inline unsigned char	492	ecb_inline unsigned char
468	ecb_byteorder_helper (void)	493	ecb_byteorder_helper (void)
469	{	494	{
470	const uint32_t u = 0x11223344;	495	/* the union code still generates code under pressure in gcc, */
471	return (unsigned char )&u;	496	/* but less than using pointers, and always seems to */
		497	/* successfully return a constant. */
		498	/* the reason why we have this horrible preprocessor mess */
		499	/* is to avoid it in all cases, at least on common architectures */
		500	/* or when using a recent enough gcc version (>= 4.6) */
		501	#if __i386 \|\| __i386__ \|\| _M_X86 \|\| __amd64 \|\| __amd64__ \|\| _M_X64
		502	return 0x44;
		503	#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
		504	return 0x44;
		505	#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
		506	return 0x11;
		507	#else
		508	union
		509	{
		510	uint32_t i;
		511	uint8_t c;
		512	} u = { 0x11223344 };
		513	return u.c;
		514	#endif
472	}	515	}
473		516
474	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;	517	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
475	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }	518	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
476	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;	519	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
…		…
507	}	550	}
508	#else	551	#else
509	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	552	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
510	#endif	553	#endif
511		554
		555	/*******************************************************************************/
		556	/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
		557
		558	/* basically, everything uses "ieee pure-endian" floating point numbers */
		559	/* the only noteworthy exception is ancient armle, which uses order 43218765 */
		560	#if 0 \
		561	\|\| __i386 \|\| __i386__ \
		562	\|\| __amd64 \|\| __amd64__ \|\| __x86_64 \|\| __x86_64__ \
		563	\|\| __powerpc__ \|\| __ppc__ \|\| __powerpc64__ \|\| __ppc64__ \
		564	\|\| defined __arm__ && defined __ARM_EABI__ \
		565	\|\| defined __s390__ \|\| defined __s390x__ \
		566	\|\| defined __mips__ \
		567	\|\| defined __alpha__ \
		568	\|\| defined __hppa__ \
		569	\|\| defined __ia64__ \
		570	\|\| defined _M_IX86 \|\| defined _M_AMD64 \|\| defined _M_IA64
		571	#define ECB_STDFP 1
		572	#include <string.h> /* for memcpy */
		573	#else
		574	#define ECB_STDFP 0
		575	#include <math.h> /* for frexp, ldexp */
		576	#endif
		577
		578	#ifndef ECB_NO_LIBM
		579
		580	/* convert a float to ieee single/binary32 */
		581	ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
		582	ecb_function_ uint32_t
		583	ecb_float_to_binary32 (float x)
		584	{
		585	uint32_t r;
		586
		587	#if ECB_STDFP
		588	memcpy (&r, &x, 4);
		589	#else
		590	/* slow emulation, works for anything but -0 */
		591	uint32_t m;
		592	int e;
		593
		594	if (x == 0e0f ) return 0x00000000U;
		595	if (x > +3.40282346638528860e+38f) return 0x7f800000U;
		596	if (x < -3.40282346638528860e+38f) return 0xff800000U;
		597	if (x != x ) return 0x7fbfffffU;
		598
		599	m = frexpf (x, &e) * 0x1000000U;
		600
		601	r = m & 0x80000000U;
		602
		603	if (r)
		604	m = -m;
		605
		606	if (e <= -126)
		607	{
		608	m &= 0xffffffU;
		609	m >>= (-125 - e);
		610	e = -126;
		611	}
		612
		613	r \|= (e + 126) << 23;
		614	r \|= m & 0x7fffffU;
512	#endif	615	#endif
513		616
		617	return r;
		618	}
		619
		620	/* converts an ieee single/binary32 to a float */
		621	ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
		622	ecb_function_ float
		623	ecb_binary32_to_float (uint32_t x)
		624	{
		625	float r;
		626
		627	#if ECB_STDFP
		628	memcpy (&r, &x, 4);
		629	#else
		630	/* emulation, only works for normals and subnormals and +0 */
		631	int neg = x >> 31;
		632	int e = (x >> 23) & 0xffU;
		633
		634	x &= 0x7fffffU;
		635
		636	if (e)
		637	x \|= 0x800000U;
		638	else
		639	e = 1;
		640
		641	/* we distrust ldexpf a bit and do the 2*-24 scaling by an extra multiply /
		642	r = ldexpf (x * (0.5f / 0x800000U), e - 126);
		643
		644	r = neg ? -r : r;
		645	#endif
		646
		647	return r;
		648	}
		649
		650	/* convert a double to ieee double/binary64 */
		651	ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
		652	ecb_function_ uint64_t
		653	ecb_double_to_binary64 (double x)
		654	{
		655	uint64_t r;
		656
		657	#if ECB_STDFP
		658	memcpy (&r, &x, 8);
		659	#else
		660	/* slow emulation, works for anything but -0 */
		661	uint64_t m;
		662	int e;
		663
		664	if (x == 0e0 ) return 0x0000000000000000U;
		665	if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
		666	if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
		667	if (x != x ) return 0X7ff7ffffffffffffU;
		668
		669	m = frexp (x, &e) * 0x20000000000000U;
		670
		671	r = m & 0x8000000000000000;;
		672
		673	if (r)
		674	m = -m;
		675
		676	if (e <= -1022)
		677	{
		678	m &= 0x1fffffffffffffU;
		679	m >>= (-1021 - e);
		680	e = -1022;
		681	}
		682
		683	r \|= ((uint64_t)(e + 1022)) << 52;
		684	r \|= m & 0xfffffffffffffU;
		685	#endif
		686
		687	return r;
		688	}
		689
		690	/* converts an ieee double/binary64 to a double */
		691	ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
		692	ecb_function_ double
		693	ecb_binary64_to_double (uint64_t x)
		694	{
		695	double r;
		696
		697	#if ECB_STDFP
		698	memcpy (&r, &x, 8);
		699	#else
		700	/* emulation, only works for normals and subnormals and +0 */
		701	int neg = x >> 63;
		702	int e = (x >> 52) & 0x7ffU;
		703
		704	x &= 0xfffffffffffffU;
		705
		706	if (e)
		707	x \|= 0x10000000000000U;
		708	else
		709	e = 1;
		710
		711	/* we distrust ldexp a bit and do the 2*-53 scaling by an extra multiply /
		712	r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
		713
		714	r = neg ? -r : r;
		715	#endif
		716
		717	return r;
		718	}
		719
		720	#endif
		721
		722	#endif
		723

Diff Legend

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

Comparing libeio/ecb.h (file contents): Revision 1.13 by root, Sat Jun 2 20:13:26 2012 UTC vs. Revision 1.17 by root, Fri Dec 28 07:33:41 2012 UTC

Diff Legend

Comparing libeio/ecb.h (file contents):
Revision 1.13 by root, Sat Jun 2 20:13:26 2012 UTC vs.
Revision 1.17 by root, Fri Dec 28 07:33:41 2012 UTC