ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.435 by root, Sat May 26 08:52:09 2012 UTC vs.
Revision 1.480 by root, Thu Feb 18 04:48:05 2016 UTC

1	/*	1	/*
2	* libev event processing core, watcher management	2	* libev event processing core, watcher management
3	*	3	*
4	* Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>	4	* Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without modifica-	7	* Redistribution and use in source and binary forms, with or without modifica-
8	* tion, are permitted provided that the following conditions are met:	8	* tion, are permitted provided that the following conditions are met:
9	*	9	*
…		…
43	# include EV_CONFIG_H	43	# include EV_CONFIG_H
44	# else	44	# else
45	# include "config.h"	45	# include "config.h"
46	# endif	46	# endif
47		47
48	#if HAVE_FLOOR	48	# if HAVE_FLOOR
49	# ifndef EV_USE_FLOOR	49	# ifndef EV_USE_FLOOR
50	# define EV_USE_FLOOR 1	50	# define EV_USE_FLOOR 1
		51	# endif
51	# endif	52	# endif
52	#endif
53		53
54	# if HAVE_CLOCK_SYSCALL	54	# if HAVE_CLOCK_SYSCALL
55	# ifndef EV_USE_CLOCK_SYSCALL	55	# ifndef EV_USE_CLOCK_SYSCALL
56	# define EV_USE_CLOCK_SYSCALL 1	56	# define EV_USE_CLOCK_SYSCALL 1
57	# ifndef EV_USE_REALTIME	57	# ifndef EV_USE_REALTIME
…		…
241	#elif defined SIGARRAYSIZE	241	#elif defined SIGARRAYSIZE
242	# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */	242	# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
243	#elif defined _sys_nsig	243	#elif defined _sys_nsig
244	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */	244	# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
245	#else	245	#else
246	# error "unable to find value for NSIG, please report"	246	# define EV_NSIG (8 * sizeof (sigset_t) + 1)
247	/* to make it compile regardless, just remove the above line, */
248	/* but consider reporting it, too! :) */
249	# define EV_NSIG 65
250	#endif	247	#endif
251		248
252	#ifndef EV_USE_FLOOR	249	#ifndef EV_USE_FLOOR
253	# define EV_USE_FLOOR 0	250	# define EV_USE_FLOOR 0
254	#endif	251	#endif
255		252
256	#ifndef EV_USE_CLOCK_SYSCALL	253	#ifndef EV_USE_CLOCK_SYSCALL
257	# if __linux && __GLIBC__ >= 2	254	# if __linux && __GLIBC__ == 2 && __GLIBC_MINOR__ < 17
258	# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS	255	# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
259	# else	256	# else
260	# define EV_USE_CLOCK_SYSCALL 0	257	# define EV_USE_CLOCK_SYSCALL 0
		258	# endif
		259	#endif
		260
		261	#if !(_POSIX_TIMERS > 0)
		262	# ifndef EV_USE_MONOTONIC
		263	# define EV_USE_MONOTONIC 0
		264	# endif
		265	# ifndef EV_USE_REALTIME
		266	# define EV_USE_REALTIME 0
261	# endif	267	# endif
262	#endif	268	#endif
263		269
264	#ifndef EV_USE_MONOTONIC	270	#ifndef EV_USE_MONOTONIC
265	# if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0	271	# if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
…		…
355	# define EV_USE_4HEAP EV_FEATURE_DATA	361	# define EV_USE_4HEAP EV_FEATURE_DATA
356	#endif	362	#endif
357		363
358	#ifndef EV_HEAP_CACHE_AT	364	#ifndef EV_HEAP_CACHE_AT
359	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA	365	# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
		366	#endif
		367
		368	#ifdef ANDROID
		369	/* supposedly, android doesn't typedef fd_mask */
		370	# undef EV_USE_SELECT
		371	# define EV_USE_SELECT 0
		372	/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
		373	# undef EV_USE_CLOCK_SYSCALL
		374	# define EV_USE_CLOCK_SYSCALL 0
		375	#endif
		376
		377	/* aix's poll.h seems to cause lots of trouble */
		378	#ifdef _AIX
		379	/* AIX has a completely broken poll.h header */
		380	# undef EV_USE_POLL
		381	# define EV_USE_POLL 0
360	#endif	382	#endif
361		383
362	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */	384	/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
363	/* which makes programs even slower. might work on other unices, too. */	385	/* which makes programs even slower. might work on other unices, too. */
364	#if EV_USE_CLOCK_SYSCALL	386	#if EV_USE_CLOCK_SYSCALL
…		…
372	# define EV_USE_CLOCK_SYSCALL 0	394	# define EV_USE_CLOCK_SYSCALL 0
373	# endif	395	# endif
374	#endif	396	#endif
375		397
376	/* this block fixes any misconfiguration where we know we run into trouble otherwise */	398	/* this block fixes any misconfiguration where we know we run into trouble otherwise */
377
378	#ifdef _AIX
379	/* AIX has a completely broken poll.h header */
380	# undef EV_USE_POLL
381	# define EV_USE_POLL 0
382	#endif
383		399
384	#ifndef CLOCK_MONOTONIC	400	#ifndef CLOCK_MONOTONIC
385	# undef EV_USE_MONOTONIC	401	# undef EV_USE_MONOTONIC
386	# define EV_USE_MONOTONIC 0	402	# define EV_USE_MONOTONIC 0
387	#endif	403	#endif
…		…
475	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */	491	/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
476	/* ECB.H BEGIN */	492	/* ECB.H BEGIN */
477	/*	493	/*
478	* libecb - http://software.schmorp.de/pkg/libecb	494	* libecb - http://software.schmorp.de/pkg/libecb
479	*	495	*
480	* Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>	496	* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
481	* Copyright (©) 2011 Emanuele Giaquinta	497	* Copyright (©) 2011 Emanuele Giaquinta
482	* All rights reserved.	498	* All rights reserved.
483	*	499	*
484	* Redistribution and use in source and binary forms, with or without modifica-	500	* Redistribution and use in source and binary forms, with or without modifica-
485	* tion, are permitted provided that the following conditions are met:	501	* tion, are permitted provided that the following conditions are met:
…		…
499	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;	515	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
500	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,	516	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
501	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-	517	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
502	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED	518	* ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
503	* OF THE POSSIBILITY OF SUCH DAMAGE.	519	* OF THE POSSIBILITY OF SUCH DAMAGE.
		520	*
		521	* Alternatively, the contents of this file may be used under the terms of
		522	* the GNU General Public License ("GPL") version 2 or any later version,
		523	* in which case the provisions of the GPL are applicable instead of
		524	* the above. If you wish to allow the use of your version of this file
		525	* only under the terms of the GPL and not to allow others to use your
		526	* version of this file under the BSD license, indicate your decision
		527	* by deleting the provisions above and replace them with the notice
		528	* and other provisions required by the GPL. If you do not delete the
		529	* provisions above, a recipient may use your version of this file under
		530	* either the BSD or the GPL.
504	*/	531	*/
505		532
506	#ifndef ECB_H	533	#ifndef ECB_H
507	#define ECB_H	534	#define ECB_H
		535
		536	/* 16 bits major, 16 bits minor */
		537	#define ECB_VERSION 0x00010005
508		538
509	#ifdef _WIN32	539	#ifdef _WIN32
510	typedef signed char int8_t;	540	typedef signed char int8_t;
511	typedef unsigned char uint8_t;	541	typedef unsigned char uint8_t;
512	typedef signed short int16_t;	542	typedef signed short int16_t;
…		…
518	typedef unsigned long long uint64_t;	548	typedef unsigned long long uint64_t;
519	#else /* _MSC_VER || __BORLANDC__ */	549	#else /* _MSC_VER || __BORLANDC__ */
520	typedef signed __int64 int64_t;	550	typedef signed __int64 int64_t;
521	typedef unsigned __int64 uint64_t;	551	typedef unsigned __int64 uint64_t;
522	#endif	552	#endif
		553	#ifdef _WIN64
		554	#define ECB_PTRSIZE 8
		555	typedef uint64_t uintptr_t;
		556	typedef int64_t intptr_t;
		557	#else
		558	#define ECB_PTRSIZE 4
		559	typedef uint32_t uintptr_t;
		560	typedef int32_t intptr_t;
		561	#endif
523	#else	562	#else
524	#include <inttypes.h>	563	#include <inttypes.h>
		564	#if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
		565	#define ECB_PTRSIZE 8
		566	#else
		567	#define ECB_PTRSIZE 4
		568	#endif
		569	#endif
		570
		571	#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
		572	#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
		573
		574	/* work around x32 idiocy by defining proper macros */
		575	#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
		576	#if _ILP32
		577	#define ECB_AMD64_X32 1
		578	#else
		579	#define ECB_AMD64 1
		580	#endif
525	#endif	581	#endif
526		582
527	/* many compilers define _GNUC_ to some versions but then only implement	583	/* many compilers define _GNUC_ to some versions but then only implement
528	* what their idiot authors think are the "more important" extensions,	584	* what their idiot authors think are the "more important" extensions,
529	* causing enormous grief in return for some better fake benchmark numbers.	585	* causing enormous grief in return for some better fake benchmark numbers.
530	* or so.	586	* or so.
531	* we try to detect these and simply assume they are not gcc - if they have	587	* we try to detect these and simply assume they are not gcc - if they have
532	* an issue with that they should have done it right in the first place.	588	* an issue with that they should have done it right in the first place.
533	*/	589	*/
534	#ifndef ECB_GCC_VERSION
535	#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__	590	#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
536	#define ECB_GCC_VERSION(major,minor) 0	591	#define ECB_GCC_VERSION(major,minor) 0
537	#else	592	#else
538	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))	593	#define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
539	#endif	594	#endif
		595
		596	#define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
		597
		598	#if __clang__ && defined __has_builtin
		599	#define ECB_CLANG_BUILTIN(x) __has_builtin (x)
		600	#else
		601	#define ECB_CLANG_BUILTIN(x) 0
		602	#endif
		603
		604	#if __clang__ && defined __has_extension
		605	#define ECB_CLANG_EXTENSION(x) __has_extension (x)
		606	#else
		607	#define ECB_CLANG_EXTENSION(x) 0
		608	#endif
		609
		610	#define ECB_CPP (__cplusplus+0)
		611	#define ECB_CPP11 (__cplusplus >= 201103L)
		612
		613	#if ECB_CPP
		614	#define ECB_C 0
		615	#define ECB_STDC_VERSION 0
		616	#else
		617	#define ECB_C 1
		618	#define ECB_STDC_VERSION __STDC_VERSION__
		619	#endif
		620
		621	#define ECB_C99 (ECB_STDC_VERSION >= 199901L)
		622	#define ECB_C11 (ECB_STDC_VERSION >= 201112L)
		623
		624	#if ECB_CPP
		625	#define ECB_EXTERN_C extern "C"
		626	#define ECB_EXTERN_C_BEG ECB_EXTERN_C {
		627	#define ECB_EXTERN_C_END }
		628	#else
		629	#define ECB_EXTERN_C extern
		630	#define ECB_EXTERN_C_BEG
		631	#define ECB_EXTERN_C_END
540	#endif	632	#endif
541		633
542	/*****************************************************************************/	634	/*****************************************************************************/
543		635
544	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */	636	/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
545	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */	637	/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
546		638
547	#if ECB_NO_THREADS	639	#if ECB_NO_THREADS
548	# define ECB_NO_SMP 1	640	#define ECB_NO_SMP 1
549	#endif	641	#endif
550		642
551	#if ECB_NO_THREADS || ECB_NO_SMP	643	#if ECB_NO_SMP
552	#define ECB_MEMORY_FENCE do { } while (0)	644	#define ECB_MEMORY_FENCE do { } while (0)
		645	#endif
		646
		647	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
		648	#if __xlC__ && ECB_CPP
		649	#include <builtins.h>
		650	#endif
		651
		652	#if 1400 <= _MSC_VER
		653	#include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
553	#endif	654	#endif
554		655
555	#ifndef ECB_MEMORY_FENCE	656	#ifndef ECB_MEMORY_FENCE
556	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110	657	#if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
557	#if __i386 || __i386__	658	#if __i386 || __i386__
558	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")	659	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
559	#define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE /* non-lock xchg might be enough */	660	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
560	#define ECB_MEMORY_FENCE_RELEASE do { } while (0) /* unlikely to change in future cpus */	661	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
561	#elif __amd64 || __amd64__ || __x86_64 || __x86_64__	662	#elif ECB_GCC_AMD64
562	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")	663	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
563	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("lfence" : : : "memory")	664	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
564	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("sfence") /* play safe - not needed in any current cpu */	665	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
565	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__	666	#elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
566	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	667	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
		668	#elif defined __ARM_ARCH_2__ \
		669	|| defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
		670	|| defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
		671	|| defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
		672	|| defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
		673	|| defined __ARM_ARCH_5TEJ__
		674	/* should not need any, unless running old code on newer cpu - arm doesn't support that */
567	#elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \	675	#elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
568	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__	676	|| defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
		677	|| defined __ARM_ARCH_6T2__
569	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")	678	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
570	#elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \	679	#elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
571	|| defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__	680	|| defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
572	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")	681	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
573	#elif __sparc || __sparc__	682	#elif __aarch64__
		683	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
		684	#elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
574	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad | " : : : "memory")	685	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
575	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")	686	#define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
576	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")	687	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
577	#elif defined __s390__ || defined __s390x__	688	#elif defined __s390__ || defined __s390x__
578	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")	689	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
579	#elif defined __mips__	690	#elif defined __mips__
		691	/* GNU/Linux emulates sync on mips1 architectures, so we force its use */
		692	/* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
580	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")	693	#define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
581	#elif defined __alpha__	694	#elif defined __alpha__
582	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")	695	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
		696	#elif defined __hppa__
		697	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		698	#define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
		699	#elif defined __ia64__
		700	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
		701	#elif defined __m68k__
		702	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
		703	#elif defined __m88k__
		704	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
		705	#elif defined __sh__
		706	#define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
583	#endif	707	#endif
584	#endif	708	#endif
585	#endif	709	#endif
586		710
587	#ifndef ECB_MEMORY_FENCE	711	#ifndef ECB_MEMORY_FENCE
		712	#if ECB_GCC_VERSION(4,7)
		713	/* see comment below (stdatomic.h) about the C11 memory model. */
		714	#define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
		715	#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
		716	#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
		717
		718	#elif ECB_CLANG_EXTENSION(c_atomic)
		719	/* see comment below (stdatomic.h) about the C11 memory model. */
		720	#define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
		721	#define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
		722	#define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
		723
588	#if ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__	724	#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
589	#define ECB_MEMORY_FENCE __sync_synchronize ()	725	#define ECB_MEMORY_FENCE __sync_synchronize ()
590	/*#define ECB_MEMORY_FENCE_ACQUIRE ({ char dummy = 0; __sync_lock_test_and_set (&dummy, 1); }) */	726	#elif _MSC_VER >= 1500 /* VC++ 2008 */
591	/*#define ECB_MEMORY_FENCE_RELEASE ({ char dummy = 1; __sync_lock_release (&dummy ); }) */	727	/* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
		728	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
		729	#define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
		730	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
		731	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
592	#elif _MSC_VER >= 1400 /* VC++ 2005 */	732	#elif _MSC_VER >= 1400 /* VC++ 2005 */
593	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)	733	#pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
594	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()	734	#define ECB_MEMORY_FENCE _ReadWriteBarrier ()
595	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */	735	#define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
596	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()	736	#define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
…		…
606	#define ECB_MEMORY_FENCE __sync ()	746	#define ECB_MEMORY_FENCE __sync ()
607	#endif	747	#endif
608	#endif	748	#endif
609		749
610	#ifndef ECB_MEMORY_FENCE	750	#ifndef ECB_MEMORY_FENCE
		751	#if ECB_C11 && !defined __STDC_NO_ATOMICS__
		752	/* we assume that these memory fences work on all variables/all memory accesses, */
		753	/* not just C11 atomics and atomic accesses */
		754	#include <stdatomic.h>
		755	/* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
		756	/* any fence other than seq_cst, which isn't very efficient for us. */
		757	/* Why that is, we don't know - either the C11 memory model is quite useless */
		758	/* for most usages, or gcc and clang have a bug */
		759	/* I *currently* lean towards the latter, and inefficiently implement */
		760	/* all three of ecb's fences as a seq_cst fence */
		761	/* Update, gcc-4.8 generates mfence for all c++ fences, but nothing */
		762	/* for all __atomic_thread_fence's except seq_cst */
		763	#define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
		764	#endif
		765	#endif
		766
		767	#ifndef ECB_MEMORY_FENCE
611	#if !ECB_AVOID_PTHREADS	768	#if !ECB_AVOID_PTHREADS
612	/*	769	/*
613	* if you get undefined symbol references to pthread_mutex_lock,	770	* if you get undefined symbol references to pthread_mutex_lock,
614	* or failure to find pthread.h, then you should implement	771	* or failure to find pthread.h, then you should implement
615	* the ECB_MEMORY_FENCE operations for your cpu/compiler	772	* the ECB_MEMORY_FENCE operations for your cpu/compiler
…		…
633	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE	790	#define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
634	#endif	791	#endif
635		792
636	/*****************************************************************************/	793	/*****************************************************************************/
637		794
638	#define ECB_C99 (__STDC_VERSION__ >= 199901L)	795	#if ECB_CPP
639
640	#if __cplusplus
641	#define ecb_inline static inline	796	#define ecb_inline static inline
642	#elif ECB_GCC_VERSION(2,5)	797	#elif ECB_GCC_VERSION(2,5)
643	#define ecb_inline static __inline__	798	#define ecb_inline static __inline__
644	#elif ECB_C99	799	#elif ECB_C99
645	#define ecb_inline static inline	800	#define ecb_inline static inline
…		…
659		814
660	#define ECB_CONCAT_(a, b) a ## b	815	#define ECB_CONCAT_(a, b) a ## b
661	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)	816	#define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
662	#define ECB_STRINGIFY_(a) # a	817	#define ECB_STRINGIFY_(a) # a
663	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)	818	#define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
		819	#define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
664		820
665	#define ecb_function_ ecb_inline	821	#define ecb_function_ ecb_inline
666		822
667	#if ECB_GCC_VERSION(3,1)	823	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
668	#define ecb_attribute(attrlist) __attribute__(attrlist)	824	#define ecb_attribute(attrlist) __attribute__ (attrlist)
		825	#else
		826	#define ecb_attribute(attrlist)
		827	#endif
		828
		829	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
669	#define ecb_is_constant(expr) __builtin_constant_p (expr)	830	#define ecb_is_constant(expr) __builtin_constant_p (expr)
		831	#else
		832	/* possible C11 impl for integral types
		833	typedef struct ecb_is_constant_struct ecb_is_constant_struct;
		834	#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
		835
		836	#define ecb_is_constant(expr) 0
		837	#endif
		838
		839	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
670	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))	840	#define ecb_expect(expr,value) __builtin_expect ((expr),(value))
		841	#else
		842	#define ecb_expect(expr,value) (expr)
		843	#endif
		844
		845	#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
671	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)	846	#define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
672	#else	847	#else
673	#define ecb_attribute(attrlist)
674	#define ecb_is_constant(expr) 0
675	#define ecb_expect(expr,value) (expr)
676	#define ecb_prefetch(addr,rw,locality)	848	#define ecb_prefetch(addr,rw,locality)
677	#endif	849	#endif
678		850
679	/* no emulation for ecb_decltype */	851	/* no emulation for ecb_decltype */
680	#if ECB_GCC_VERSION(4,5)	852	#if ECB_CPP11
		853	// older implementations might have problems with decltype(x)::type, work around it
		854	template<class T> struct ecb_decltype_t { typedef T type; };
681	#define ecb_decltype(x) __decltype(x)	855	#define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
682	#elif ECB_GCC_VERSION(3,0)	856	#elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
683	#define ecb_decltype(x) __typeof(x)	857	#define ecb_decltype(x) __typeof__ (x)
684	#endif	858	#endif
685		859
		860	#if _MSC_VER >= 1300
		861	#define ecb_deprecated __declspec (deprecated)
		862	#else
		863	#define ecb_deprecated ecb_attribute ((__deprecated__))
		864	#endif
		865
		866	#if _MSC_VER >= 1500
		867	#define ecb_deprecated_message(msg) __declspec (deprecated (msg))
		868	#elif ECB_GCC_VERSION(4,5)
		869	#define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
		870	#else
		871	#define ecb_deprecated_message(msg) ecb_deprecated
		872	#endif
		873
		874	#if _MSC_VER >= 1400
		875	#define ecb_noinline __declspec (noinline)
		876	#else
686	#define ecb_noinline ecb_attribute ((__noinline__))	877	#define ecb_noinline ecb_attribute ((__noinline__))
687	#define ecb_noreturn ecb_attribute ((__noreturn__))	878	#endif
		879
688	#define ecb_unused ecb_attribute ((__unused__))	880	#define ecb_unused ecb_attribute ((__unused__))
689	#define ecb_const ecb_attribute ((__const__))	881	#define ecb_const ecb_attribute ((__const__))
690	#define ecb_pure ecb_attribute ((__pure__))	882	#define ecb_pure ecb_attribute ((__pure__))
		883
		884	#if ECB_C11 || __IBMC_NORETURN
		885	/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
		886	#define ecb_noreturn _Noreturn
		887	#elif ECB_CPP11
		888	#define ecb_noreturn [[noreturn]]
		889	#elif _MSC_VER >= 1200
		890	/* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
		891	#define ecb_noreturn __declspec (noreturn)
		892	#else
		893	#define ecb_noreturn ecb_attribute ((__noreturn__))
		894	#endif
691		895
692	#if ECB_GCC_VERSION(4,3)	896	#if ECB_GCC_VERSION(4,3)
693	#define ecb_artificial ecb_attribute ((__artificial__))	897	#define ecb_artificial ecb_attribute ((__artificial__))
694	#define ecb_hot ecb_attribute ((__hot__))	898	#define ecb_hot ecb_attribute ((__hot__))
695	#define ecb_cold ecb_attribute ((__cold__))	899	#define ecb_cold ecb_attribute ((__cold__))
…		…
707	/* for compatibility to the rest of the world */	911	/* for compatibility to the rest of the world */
708	#define ecb_likely(expr) ecb_expect_true (expr)	912	#define ecb_likely(expr) ecb_expect_true (expr)
709	#define ecb_unlikely(expr) ecb_expect_false (expr)	913	#define ecb_unlikely(expr) ecb_expect_false (expr)
710		914
711	/* count trailing zero bits and count # of one bits */	915	/* count trailing zero bits and count # of one bits */
712	#if ECB_GCC_VERSION(3,4)	916	#if ECB_GCC_VERSION(3,4) \
		917	|| (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
		918	&& ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
		919	&& ECB_CLANG_BUILTIN(__builtin_popcount))
713	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */	920	/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
714	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)	921	#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
715	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)	922	#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
716	#define ecb_ctz32(x) __builtin_ctz (x)	923	#define ecb_ctz32(x) __builtin_ctz (x)
717	#define ecb_ctz64(x) __builtin_ctzll (x)	924	#define ecb_ctz64(x) __builtin_ctzll (x)
718	#define ecb_popcount32(x) __builtin_popcount (x)	925	#define ecb_popcount32(x) __builtin_popcount (x)
719	/* no popcountll */	926	/* no popcountll */
720	#else	927	#else
721	ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;	928	ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
722	ecb_function_ int	929	ecb_function_ ecb_const int
723	ecb_ctz32 (uint32_t x)	930	ecb_ctz32 (uint32_t x)
724	{	931	{
		932	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		933	unsigned long r;
		934	_BitScanForward (&r, x);
		935	return (int)r;
		936	#else
725	int r = 0;	937	int r = 0;
726		938
727	x &= ~x + 1; /* this isolates the lowest bit */	939	x &= ~x + 1; /* this isolates the lowest bit */
728		940
729	#if ECB_branchless_on_i386	941	#if ECB_branchless_on_i386
…		…
739	if (x & 0xff00ff00) r += 8;	951	if (x & 0xff00ff00) r += 8;
740	if (x & 0xffff0000) r += 16;	952	if (x & 0xffff0000) r += 16;
741	#endif	953	#endif
742		954
743	return r;	955	return r;
		956	#endif
744	}	957	}
745		958
746	ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;	959	ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
747	ecb_function_ int	960	ecb_function_ ecb_const int
748	ecb_ctz64 (uint64_t x)	961	ecb_ctz64 (uint64_t x)
749	{	962	{
		963	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		964	unsigned long r;
		965	_BitScanForward64 (&r, x);
		966	return (int)r;
		967	#else
750	int shift = x & 0xffffffffU ? 0 : 32;	968	int shift = x & 0xffffffff ? 0 : 32;
751	return ecb_ctz32 (x >> shift) + shift;	969	return ecb_ctz32 (x >> shift) + shift;
		970	#endif
752	}	971	}
753		972
754	ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;	973	ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
755	ecb_function_ int	974	ecb_function_ ecb_const int
756	ecb_popcount32 (uint32_t x)	975	ecb_popcount32 (uint32_t x)
757	{	976	{
758	x -= (x >> 1) & 0x55555555;	977	x -= (x >> 1) & 0x55555555;
759	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);	978	x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
760	x = ((x >> 4) + x) & 0x0f0f0f0f;	979	x = ((x >> 4) + x) & 0x0f0f0f0f;
761	x *= 0x01010101;	980	x *= 0x01010101;
762		981
763	return x >> 24;	982	return x >> 24;
764	}	983	}
765		984
766	ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;	985	ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
767	ecb_function_ int ecb_ld32 (uint32_t x)	986	ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
768	{	987	{
		988	#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
		989	unsigned long r;
		990	_BitScanReverse (&r, x);
		991	return (int)r;
		992	#else
769	int r = 0;	993	int r = 0;
770		994
771	if (x >> 16) { x >>= 16; r += 16; }	995	if (x >> 16) { x >>= 16; r += 16; }
772	if (x >> 8) { x >>= 8; r += 8; }	996	if (x >> 8) { x >>= 8; r += 8; }
773	if (x >> 4) { x >>= 4; r += 4; }	997	if (x >> 4) { x >>= 4; r += 4; }
774	if (x >> 2) { x >>= 2; r += 2; }	998	if (x >> 2) { x >>= 2; r += 2; }
775	if (x >> 1) { r += 1; }	999	if (x >> 1) { r += 1; }
776		1000
777	return r;	1001	return r;
		1002	#endif
778	}	1003	}
779		1004
780	ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;	1005	ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
781	ecb_function_ int ecb_ld64 (uint64_t x)	1006	ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
782	{	1007	{
		1008	#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
		1009	unsigned long r;
		1010	_BitScanReverse64 (&r, x);
		1011	return (int)r;
		1012	#else
783	int r = 0;	1013	int r = 0;
784		1014
785	if (x >> 32) { x >>= 32; r += 32; }	1015	if (x >> 32) { x >>= 32; r += 32; }
786		1016
787	return r + ecb_ld32 (x);	1017	return r + ecb_ld32 (x);
		1018	#endif
788	}	1019	}
789	#endif	1020	#endif
790		1021
		1022	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
		1023	ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
		1024	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
		1025	ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
		1026
791	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;	1027	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
792	ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)	1028	ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
793	{	1029	{
794	return ( (x * 0x0802U & 0x22110U)	1030	return ( (x * 0x0802U & 0x22110U)
795	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;	1031	| (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
796	}	1032	}
797		1033
798	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;	1034	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
799	ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)	1035	ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
800	{	1036	{
801	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);	1037	x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
802	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);	1038	x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
803	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);	1039	x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
804	x = ( x >> 8 ) | ( x << 8);	1040	x = ( x >> 8 ) | ( x << 8);
805		1041
806	return x;	1042	return x;
807	}	1043	}
808		1044
809	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;	1045	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
810	ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)	1046	ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
811	{	1047	{
812	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);	1048	x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
813	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);	1049	x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
814	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);	1050	x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
815	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);	1051	x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
…		…
818	return x;	1054	return x;
819	}	1055	}
820		1056
821	/* popcount64 is only available on 64 bit cpus as gcc builtin */	1057	/* popcount64 is only available on 64 bit cpus as gcc builtin */
822	/* so for this version we are lazy */	1058	/* so for this version we are lazy */
823	ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;	1059	ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
824	ecb_function_ int	1060	ecb_function_ ecb_const int
825	ecb_popcount64 (uint64_t x)	1061	ecb_popcount64 (uint64_t x)
826	{	1062	{
827	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);	1063	return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
828	}	1064	}
829		1065
830	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;	1066	ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
831	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;	1067	ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
832	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;	1068	ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
833	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;	1069	ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
834	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;	1070	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
835	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;	1071	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
836	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;	1072	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
837	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;	1073	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
838		1074
839	ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }	1075	ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
840	ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }	1076	ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
841	ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }	1077	ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
842	ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }	1078	ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
843	ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }	1079	ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
844	ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }	1080	ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
845	ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }	1081	ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
846	ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }	1082	ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
847		1083
848	#if ECB_GCC_VERSION(4,3)	1084	#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
		1085	#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
		1086	#define ecb_bswap16(x) __builtin_bswap16 (x)
		1087	#else
849	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)	1088	#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
		1089	#endif
850	#define ecb_bswap32(x) __builtin_bswap32 (x)	1090	#define ecb_bswap32(x) __builtin_bswap32 (x)
851	#define ecb_bswap64(x) __builtin_bswap64 (x)	1091	#define ecb_bswap64(x) __builtin_bswap64 (x)
		1092	#elif _MSC_VER
		1093	#include <stdlib.h>
		1094	#define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
		1095	#define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
		1096	#define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
852	#else	1097	#else
853	ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;	1098	ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
854	ecb_function_ uint16_t	1099	ecb_function_ ecb_const uint16_t
855	ecb_bswap16 (uint16_t x)	1100	ecb_bswap16 (uint16_t x)
856	{	1101	{
857	return ecb_rotl16 (x, 8);	1102	return ecb_rotl16 (x, 8);
858	}	1103	}
859		1104
860	ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;	1105	ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
861	ecb_function_ uint32_t	1106	ecb_function_ ecb_const uint32_t
862	ecb_bswap32 (uint32_t x)	1107	ecb_bswap32 (uint32_t x)
863	{	1108	{
864	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);	1109	return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
865	}	1110	}
866		1111
867	ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;	1112	ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
868	ecb_function_ uint64_t	1113	ecb_function_ ecb_const uint64_t
869	ecb_bswap64 (uint64_t x)	1114	ecb_bswap64 (uint64_t x)
870	{	1115	{
871	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);	1116	return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
872	}	1117	}
873	#endif	1118	#endif
874		1119
875	#if ECB_GCC_VERSION(4,5)	1120	#if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
876	#define ecb_unreachable() __builtin_unreachable ()	1121	#define ecb_unreachable() __builtin_unreachable ()
877	#else	1122	#else
878	/* this seems to work fine, but gcc always emits a warning for it :/ */	1123	/* this seems to work fine, but gcc always emits a warning for it :/ */
879	ecb_inline void ecb_unreachable (void) ecb_noreturn;	1124	ecb_inline ecb_noreturn void ecb_unreachable (void);
880	ecb_inline void ecb_unreachable (void) { }	1125	ecb_inline ecb_noreturn void ecb_unreachable (void) { }
881	#endif	1126	#endif
882		1127
883	/* try to tell the compiler that some condition is definitely true */	1128	/* try to tell the compiler that some condition is definitely true */
884	#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0)	1129	#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
885		1130
886	ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;	1131	ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
887	ecb_inline unsigned char	1132	ecb_inline ecb_const uint32_t
888	ecb_byteorder_helper (void)	1133	ecb_byteorder_helper (void)
889	{	1134	{
890	const uint32_t u = 0x11223344;	1135	/* the union code still generates code under pressure in gcc, */
891	return *(unsigned char *)&u;	1136	/* but less than using pointers, and always seems to */
		1137	/* successfully return a constant. */
		1138	/* the reason why we have this horrible preprocessor mess */
		1139	/* is to avoid it in all cases, at least on common architectures */
		1140	/* or when using a recent enough gcc version (>= 4.6) */
		1141	#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
		1142	|| ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
		1143	#define ECB_LITTLE_ENDIAN 1
		1144	return 0x44332211;
		1145	#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
		1146	|| ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
		1147	#define ECB_BIG_ENDIAN 1
		1148	return 0x11223344;
		1149	#else
		1150	union
		1151	{
		1152	uint8_t c[4];
		1153	uint32_t u;
		1154	} u = { 0x11, 0x22, 0x33, 0x44 };
		1155	return u.u;
		1156	#endif
892	}	1157	}
893		1158
894	ecb_inline ecb_bool ecb_big_endian (void) ecb_const;	1159	ecb_inline ecb_const ecb_bool ecb_big_endian (void);
895	ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }	1160	ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
896	ecb_inline ecb_bool ecb_little_endian (void) ecb_const;	1161	ecb_inline ecb_const ecb_bool ecb_little_endian (void);
897	ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }	1162	ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
898		1163
899	#if ECB_GCC_VERSION(3,0) || ECB_C99	1164	#if ECB_GCC_VERSION(3,0) || ECB_C99
900	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))	1165	#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
901	#else	1166	#else
902	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))	1167	#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
903	#endif	1168	#endif
904		1169
905	#if __cplusplus	1170	#if ECB_CPP
906	template<typename T>	1171	template<typename T>
907	static inline T ecb_div_rd (T val, T div)	1172	static inline T ecb_div_rd (T val, T div)
908	{	1173	{
909	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;	1174	return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
910	}	1175	}
…		…
927	}	1192	}
928	#else	1193	#else
929	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))	1194	#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
930	#endif	1195	#endif
931		1196
		1197	ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
		1198	ecb_function_ ecb_const uint32_t
		1199	ecb_binary16_to_binary32 (uint32_t x)
		1200	{
		1201	unsigned int s = (x & 0x8000) << (31 - 15);
		1202	int e = (x >> 10) & 0x001f;
		1203	unsigned int m = x & 0x03ff;
		1204
		1205	if (ecb_expect_false (e == 31))
		1206	/* infinity or NaN */
		1207	e = 255 - (127 - 15);
		1208	else if (ecb_expect_false (!e))
		1209	{
		1210	if (ecb_expect_true (!m))
		1211	/* zero, handled by code below by forcing e to 0 */
		1212	e = 0 - (127 - 15);
		1213	else
		1214	{
		1215	/* subnormal, renormalise */
		1216	unsigned int s = 10 - ecb_ld32 (m);
		1217
		1218	m = (m << s) & 0x3ff; /* mask implicit bit */
		1219	e -= s - 1;
		1220	}
		1221	}
		1222
		1223	/* e and m now are normalised, or zero, (or inf or nan) */
		1224	e += 127 - 15;
		1225
		1226	return s | (e << 23) | (m << (23 - 10));
		1227	}
		1228
		1229	ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
		1230	ecb_function_ ecb_const uint16_t
		1231	ecb_binary32_to_binary16 (uint32_t x)
		1232	{
		1233	unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
		1234	unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
		1235	unsigned int m = x & 0x007fffff;
		1236
		1237	x &= 0x7fffffff;
		1238
		1239	/* if it's within range of binary16 normals, use fast path */
		1240	if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
		1241	{
		1242	/* mantissa round-to-even */
		1243	m += 0x00000fff + ((m >> (23 - 10)) & 1);
		1244
		1245	/* handle overflow */
		1246	if (ecb_expect_false (m >= 0x00800000))
		1247	{
		1248	m >>= 1;
		1249	e += 1;
		1250	}
		1251
		1252	return s | (e << 10) | (m >> (23 - 10));
		1253	}
		1254
		1255	/* handle large numbers and infinity */
		1256	if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
		1257	return s | 0x7c00;
		1258
		1259	/* handle zero, subnormals and small numbers */
		1260	if (ecb_expect_true (x < 0x38800000))
		1261	{
		1262	/* zero */
		1263	if (ecb_expect_true (!x))
		1264	return s;
		1265
		1266	/* handle subnormals */
		1267
		1268	/* too small, will be zero */
		1269	if (e < (14 - 24)) /* might not be sharp, but is good enough */
		1270	return s;
		1271
		1272	m |= 0x00800000; /* make implicit bit explicit */
		1273
		1274	/* very tricky - we need to round to the nearest e (+10) bit value */
		1275	{
		1276	unsigned int bits = 14 - e;
		1277	unsigned int half = (1 << (bits - 1)) - 1;
		1278	unsigned int even = (m >> bits) & 1;
		1279
		1280	/* if this overflows, we will end up with a normalised number */
		1281	m = (m + half + even) >> bits;
		1282	}
		1283
		1284	return s | m;
		1285	}
		1286
		1287	/* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
		1288	m >>= 13;
		1289
		1290	return s | 0x7c00 | m | !m;
		1291	}
		1292
		1293	/*******************************************************************************/
		1294	/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
		1295
		1296	/* basically, everything uses "ieee pure-endian" floating point numbers */
		1297	/* the only noteworthy exception is ancient armle, which uses order 43218765 */
		1298	#if 0 \
		1299	|| __i386 || __i386__ \
		1300	|| ECB_GCC_AMD64 \
		1301	|| __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
		1302	|| defined __s390__ || defined __s390x__ \
		1303	|| defined __mips__ \
		1304	|| defined __alpha__ \
		1305	|| defined __hppa__ \
		1306	|| defined __ia64__ \
		1307	|| defined __m68k__ \
		1308	|| defined __m88k__ \
		1309	|| defined __sh__ \
		1310	|| defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
		1311	|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
		1312	|| defined __aarch64__
		1313	#define ECB_STDFP 1
		1314	#include <string.h> /* for memcpy */
		1315	#else
		1316	#define ECB_STDFP 0
		1317	#endif
		1318
		1319	#ifndef ECB_NO_LIBM
		1320
		1321	#include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
		1322
		1323	/* only the oldest of old doesn't have this one. solaris. */
		1324	#ifdef INFINITY
		1325	#define ECB_INFINITY INFINITY
		1326	#else
		1327	#define ECB_INFINITY HUGE_VAL
		1328	#endif
		1329
		1330	#ifdef NAN
		1331	#define ECB_NAN NAN
		1332	#else
		1333	#define ECB_NAN ECB_INFINITY
		1334	#endif
		1335
		1336	#if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
		1337	#define ecb_ldexpf(x,e) ldexpf ((x), (e))
		1338	#define ecb_frexpf(x,e) frexpf ((x), (e))
		1339	#else
		1340	#define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
		1341	#define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
		1342	#endif
		1343
		1344	/* convert a float to ieee single/binary32 */
		1345	ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
		1346	ecb_function_ ecb_const uint32_t
		1347	ecb_float_to_binary32 (float x)
		1348	{
		1349	uint32_t r;
		1350
		1351	#if ECB_STDFP
		1352	memcpy (&r, &x, 4);
		1353	#else
		1354	/* slow emulation, works for anything but -0 */
		1355	uint32_t m;
		1356	int e;
		1357
		1358	if (x == 0e0f ) return 0x00000000U;
		1359	if (x > +3.40282346638528860e+38f) return 0x7f800000U;
		1360	if (x < -3.40282346638528860e+38f) return 0xff800000U;
		1361	if (x != x ) return 0x7fbfffffU;
		1362
		1363	m = ecb_frexpf (x, &e) * 0x1000000U;
		1364
		1365	r = m & 0x80000000U;
		1366
		1367	if (r)
		1368	m = -m;
		1369
		1370	if (e <= -126)
		1371	{
		1372	m &= 0xffffffU;
		1373	m >>= (-125 - e);
		1374	e = -126;
		1375	}
		1376
		1377	r |= (e + 126) << 23;
		1378	r |= m & 0x7fffffU;
		1379	#endif
		1380
		1381	return r;
		1382	}
		1383
		1384	/* converts an ieee single/binary32 to a float */
		1385	ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
		1386	ecb_function_ ecb_const float
		1387	ecb_binary32_to_float (uint32_t x)
		1388	{
		1389	float r;
		1390
		1391	#if ECB_STDFP
		1392	memcpy (&r, &x, 4);
		1393	#else
		1394	/* emulation, only works for normals and subnormals and +0 */
		1395	int neg = x >> 31;
		1396	int e = (x >> 23) & 0xffU;
		1397
		1398	x &= 0x7fffffU;
		1399
		1400	if (e)
		1401	x |= 0x800000U;
		1402	else
		1403	e = 1;
		1404
		1405	/* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
		1406	r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
		1407
		1408	r = neg ? -r : r;
		1409	#endif
		1410
		1411	return r;
		1412	}
		1413
		1414	/* convert a double to ieee double/binary64 */
		1415	ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
		1416	ecb_function_ ecb_const uint64_t
		1417	ecb_double_to_binary64 (double x)
		1418	{
		1419	uint64_t r;
		1420
		1421	#if ECB_STDFP
		1422	memcpy (&r, &x, 8);
		1423	#else
		1424	/* slow emulation, works for anything but -0 */
		1425	uint64_t m;
		1426	int e;
		1427
		1428	if (x == 0e0 ) return 0x0000000000000000U;
		1429	if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
		1430	if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
		1431	if (x != x ) return 0X7ff7ffffffffffffU;
		1432
		1433	m = frexp (x, &e) * 0x20000000000000U;
		1434
		1435	r = m & 0x8000000000000000;;
		1436
		1437	if (r)
		1438	m = -m;
		1439
		1440	if (e <= -1022)
		1441	{
		1442	m &= 0x1fffffffffffffU;
		1443	m >>= (-1021 - e);
		1444	e = -1022;
		1445	}
		1446
		1447	r |= ((uint64_t)(e + 1022)) << 52;
		1448	r |= m & 0xfffffffffffffU;
		1449	#endif
		1450
		1451	return r;
		1452	}
		1453
		1454	/* converts an ieee double/binary64 to a double */
		1455	ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
		1456	ecb_function_ ecb_const double
		1457	ecb_binary64_to_double (uint64_t x)
		1458	{
		1459	double r;
		1460
		1461	#if ECB_STDFP
		1462	memcpy (&r, &x, 8);
		1463	#else
		1464	/* emulation, only works for normals and subnormals and +0 */
		1465	int neg = x >> 63;
		1466	int e = (x >> 52) & 0x7ffU;
		1467
		1468	x &= 0xfffffffffffffU;
		1469
		1470	if (e)
		1471	x |= 0x10000000000000U;
		1472	else
		1473	e = 1;
		1474
		1475	/* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
		1476	r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
		1477
		1478	r = neg ? -r : r;
		1479	#endif
		1480
		1481	return r;
		1482	}
		1483
		1484	/* convert a float to ieee half/binary16 */
		1485	ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
		1486	ecb_function_ ecb_const uint16_t
		1487	ecb_float_to_binary16 (float x)
		1488	{
		1489	return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
		1490	}
		1491
		1492	/* convert an ieee half/binary16 to float */
		1493	ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
		1494	ecb_function_ ecb_const float
		1495	ecb_binary16_to_float (uint16_t x)
		1496	{
		1497	return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
		1498	}
		1499
		1500	#endif
		1501
932	#endif	1502	#endif
933		1503
934	/* ECB.H END */	1504	/* ECB.H END */
935		1505
936	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS	1506	#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
…		…
957	#define inline_size ecb_inline	1527	#define inline_size ecb_inline
958		1528
959	#if EV_FEATURE_CODE	1529	#if EV_FEATURE_CODE
960	# define inline_speed ecb_inline	1530	# define inline_speed ecb_inline
961	#else	1531	#else
962	# define inline_speed static noinline	1532	# define inline_speed noinline static
963	#endif	1533	#endif
964		1534
965	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)	1535	#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
966		1536
967	#if EV_MINPRI == EV_MAXPRI	1537	#if EV_MINPRI == EV_MAXPRI
…		…
1014	#else	1584	#else
1015		1585
1016	#include <float.h>	1586	#include <float.h>
1017		1587
1018	/* a floor() replacement function, should be independent of ev_tstamp type */	1588	/* a floor() replacement function, should be independent of ev_tstamp type */
		1589	noinline
1019	static ev_tstamp noinline	1590	static ev_tstamp
1020	ev_floor (ev_tstamp v)	1591	ev_floor (ev_tstamp v)
1021	{	1592	{
1022	/* the choice of shift factor is not terribly important */	1593	/* the choice of shift factor is not terribly important */
1023	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */	1594	#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1024	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;	1595	const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
…		…
1056		1627
1057	#ifdef __linux	1628	#ifdef __linux
1058	# include <sys/utsname.h>	1629	# include <sys/utsname.h>
1059	#endif	1630	#endif
1060		1631
1061	static unsigned int noinline ecb_cold	1632	noinline ecb_cold
		1633	static unsigned int
1062	ev_linux_version (void)	1634	ev_linux_version (void)
1063	{	1635	{
1064	#ifdef __linux	1636	#ifdef __linux
1065	unsigned int v = 0;	1637	unsigned int v = 0;
1066	struct utsname buf;	1638	struct utsname buf;
…		…
1095	}	1667	}
1096		1668
1097	/*****************************************************************************/	1669	/*****************************************************************************/
1098		1670
1099	#if EV_AVOID_STDIO	1671	#if EV_AVOID_STDIO
1100	static void noinline ecb_cold	1672	noinline ecb_cold
		1673	static void
1101	ev_printerr (const char *msg)	1674	ev_printerr (const char *msg)
1102	{	1675	{
1103	write (STDERR_FILENO, msg, strlen (msg));	1676	write (STDERR_FILENO, msg, strlen (msg));
1104	}	1677	}
1105	#endif	1678	#endif
1106		1679
1107	static void (*syserr_cb)(const char *msg) EV_THROW;	1680	static void (*syserr_cb)(const char *msg) EV_THROW;
1108		1681
1109	void ecb_cold	1682	ecb_cold
		1683	void
1110	ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW	1684	ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW
1111	{	1685	{
1112	syserr_cb = cb;	1686	syserr_cb = cb;
1113	}	1687	}
1114		1688
1115	static void noinline ecb_cold	1689	noinline ecb_cold
		1690	static void
1116	ev_syserr (const char *msg)	1691	ev_syserr (const char *msg)
1117	{	1692	{
1118	if (!msg)	1693	if (!msg)
1119	msg = "(libev) system error";	1694	msg = "(libev) system error";
1120		1695
…		…
1135	}	1710	}
1136		1711
1137	static void *	1712	static void *
1138	ev_realloc_emul (void *ptr, long size) EV_THROW	1713	ev_realloc_emul (void *ptr, long size) EV_THROW
1139	{	1714	{
1140	#if __GLIBC__
1141	return realloc (ptr, size);
1142	#else
1143	/* some systems, notably openbsd and darwin, fail to properly	1715	/* some systems, notably openbsd and darwin, fail to properly
1144	* implement realloc (x, 0) (as required by both ansi c-89 and	1716	* implement realloc (x, 0) (as required by both ansi c-89 and
1145	* the single unix specification, so work around them here.	1717	* the single unix specification, so work around them here.
		1718	* recently, also (at least) fedora and debian started breaking it,
		1719	* despite documenting it otherwise.
1146	*/	1720	*/
1147		1721
1148	if (size)	1722	if (size)
1149	return realloc (ptr, size);	1723	return realloc (ptr, size);
1150		1724
1151	free (ptr);	1725	free (ptr);
1152	return 0;	1726	return 0;
1153	#endif
1154	}	1727	}
1155		1728
1156	static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;	1729	static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1157		1730
1158	void ecb_cold	1731	ecb_cold
		1732	void
1159	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW	1733	ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW
1160	{	1734	{
1161	alloc = cb;	1735	alloc = cb;
1162	}	1736	}
1163		1737
…		…
1372	}	1946	}
1373		1947
1374	return ncur;	1948	return ncur;
1375	}	1949	}
1376		1950
1377	static void * noinline ecb_cold	1951	noinline ecb_cold
		1952	static void *
1378	array_realloc (int elem, void *base, int *cur, int cnt)	1953	array_realloc (int elem, void *base, int *cur, int cnt)
1379	{	1954	{
1380	*cur = array_nextsize (elem, *cur, cnt);	1955	*cur = array_nextsize (elem, *cur, cnt);
1381	return ev_realloc (base, elem * *cur);	1956	return ev_realloc (base, elem * *cur);
1382	}	1957	}
…		…
1385	memset ((void *)(base), 0, sizeof (*(base)) * (count))	1960	memset ((void *)(base), 0, sizeof (*(base)) * (count))
1386		1961
1387	#define array_needsize(type,base,cur,cnt,init) \	1962	#define array_needsize(type,base,cur,cnt,init) \
1388	if (expect_false ((cnt) > (cur))) \	1963	if (expect_false ((cnt) > (cur))) \
1389	{ \	1964	{ \
1390	int ecb_unused ocur_ = (cur); \	1965	ecb_unused int ocur_ = (cur); \
1391	(base) = (type *)array_realloc \	1966	(base) = (type *)array_realloc \
1392	(sizeof (type), (base), &(cur), (cnt)); \	1967	(sizeof (type), (base), &(cur), (cnt)); \
1393	init ((base) + (ocur_), (cur) - ocur_); \	1968	init ((base) + (ocur_), (cur) - ocur_); \
1394	}	1969	}
1395		1970
…		…
1407	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0	1982	ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1408		1983
1409	/*****************************************************************************/	1984	/*****************************************************************************/
1410		1985
1411	/* dummy callback for pending events */	1986	/* dummy callback for pending events */
1412	static void noinline	1987	noinline
		1988	static void
1413	pendingcb (EV_P_ ev_prepare *w, int revents)	1989	pendingcb (EV_P_ ev_prepare *w, int revents)
1414	{	1990	{
1415	}	1991	}
1416		1992
1417	void noinline	1993	noinline
		1994	void
1418	ev_feed_event (EV_P_ void *w, int revents) EV_THROW	1995	ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1419	{	1996	{
1420	W w_ = (W)w;	1997	W w_ = (W)w;
1421	int pri = ABSPRI (w_);	1998	int pri = ABSPRI (w_);
1422		1999
…		…
1552		2129
1553	fdchangecnt = 0;	2130	fdchangecnt = 0;
1554	}	2131	}
1555		2132
1556	/* something about the given fd changed */	2133	/* something about the given fd changed */
1557	inline_size void	2134	inline_size
		2135	void
1558	fd_change (EV_P_ int fd, int flags)	2136	fd_change (EV_P_ int fd, int flags)
1559	{	2137	{
1560	unsigned char reify = anfds [fd].reify;	2138	unsigned char reify = anfds [fd].reify;
1561	anfds [fd].reify |= flags;	2139	anfds [fd].reify |= flags;
1562		2140
…		…
1567	fdchanges [fdchangecnt - 1] = fd;	2145	fdchanges [fdchangecnt - 1] = fd;
1568	}	2146	}
1569	}	2147	}
1570		2148
1571	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */	2149	/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1572	inline_speed void ecb_cold	2150	inline_speed ecb_cold void
1573	fd_kill (EV_P_ int fd)	2151	fd_kill (EV_P_ int fd)
1574	{	2152	{
1575	ev_io *w;	2153	ev_io *w;
1576		2154
1577	while ((w = (ev_io *)anfds [fd].head))	2155	while ((w = (ev_io *)anfds [fd].head))
…		…
1580	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);	2158	ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1581	}	2159	}
1582	}	2160	}
1583		2161
1584	/* check whether the given fd is actually valid, for error recovery */	2162	/* check whether the given fd is actually valid, for error recovery */
1585	inline_size int ecb_cold	2163	inline_size ecb_cold int
1586	fd_valid (int fd)	2164	fd_valid (int fd)
1587	{	2165	{
1588	#ifdef _WIN32	2166	#ifdef _WIN32
1589	return EV_FD_TO_WIN32_HANDLE (fd) != -1;	2167	return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1590	#else	2168	#else
1591	return fcntl (fd, F_GETFD) != -1;	2169	return fcntl (fd, F_GETFD) != -1;
1592	#endif	2170	#endif
1593	}	2171	}
1594		2172
1595	/* called on EBADF to verify fds */	2173	/* called on EBADF to verify fds */
1596	static void noinline ecb_cold	2174	noinline ecb_cold
		2175	static void
1597	fd_ebadf (EV_P)	2176	fd_ebadf (EV_P)
1598	{	2177	{
1599	int fd;	2178	int fd;
1600		2179
1601	for (fd = 0; fd < anfdmax; ++fd)	2180	for (fd = 0; fd < anfdmax; ++fd)
…		…
1603	if (!fd_valid (fd) && errno == EBADF)	2182	if (!fd_valid (fd) && errno == EBADF)
1604	fd_kill (EV_A_ fd);	2183	fd_kill (EV_A_ fd);
1605	}	2184	}
1606		2185
1607	/* called on ENOMEM in select/poll to kill some fds and retry */	2186	/* called on ENOMEM in select/poll to kill some fds and retry */
1608	static void noinline ecb_cold	2187	noinline ecb_cold
		2188	static void
1609	fd_enomem (EV_P)	2189	fd_enomem (EV_P)
1610	{	2190	{
1611	int fd;	2191	int fd;
1612		2192
1613	for (fd = anfdmax; fd--; )	2193	for (fd = anfdmax; fd--; )
…		…
1617	break;	2197	break;
1618	}	2198	}
1619	}	2199	}
1620		2200
1621	/* usually called after fork if backend needs to re-arm all fds from scratch */	2201	/* usually called after fork if backend needs to re-arm all fds from scratch */
1622	static void noinline	2202	noinline
		2203	static void
1623	fd_rearm_all (EV_P)	2204	fd_rearm_all (EV_P)
1624	{	2205	{
1625	int fd;	2206	int fd;
1626		2207
1627	for (fd = 0; fd < anfdmax; ++fd)	2208	for (fd = 0; fd < anfdmax; ++fd)
…		…
1808		2389
1809	/*****************************************************************************/	2390	/*****************************************************************************/
1810		2391
1811	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE	2392	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
1812		2393
1813	static void noinline ecb_cold	2394	noinline ecb_cold
		2395	static void
1814	evpipe_init (EV_P)	2396	evpipe_init (EV_P)
1815	{	2397	{
1816	if (!ev_is_active (&pipe_w))	2398	if (!ev_is_active (&pipe_w))
1817	{	2399	{
		2400	int fds [2];
		2401
1818	# if EV_USE_EVENTFD	2402	# if EV_USE_EVENTFD
		2403	fds [0] = -1;
1819	evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);	2404	fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
1820	if (evfd < 0 && errno == EINVAL)	2405	if (fds [1] < 0 && errno == EINVAL)
1821	evfd = eventfd (0, 0);	2406	fds [1] = eventfd (0, 0);
1822		2407
1823	if (evfd >= 0)	2408	if (fds [1] < 0)
1824	{
1825	evpipe [0] = -1;
1826	fd_intern (evfd); /* doing it twice doesn't hurt */
1827	ev_io_set (&pipe_w, evfd, EV_READ);
1828	}
1829	else
1830	# endif	2409	# endif
1831	{	2410	{
1832	while (pipe (evpipe))	2411	while (pipe (fds))
1833	ev_syserr ("(libev) error creating signal/async pipe");	2412	ev_syserr ("(libev) error creating signal/async pipe");
1834		2413
1835	fd_intern (evpipe [0]);	2414	fd_intern (fds [0]);
1836	fd_intern (evpipe [1]);
1837	ev_io_set (&pipe_w, evpipe [0], EV_READ);
1838	}	2415	}
1839		2416
		2417	evpipe [0] = fds [0];
		2418
		2419	if (evpipe [1] < 0)
		2420	evpipe [1] = fds [1]; /* first call, set write fd */
		2421	else
		2422	{
		2423	/* on subsequent calls, do not change evpipe [1] */
		2424	/* so that evpipe_write can always rely on its value. */
		2425	/* this branch does not do anything sensible on windows, */
		2426	/* so must not be executed on windows */
		2427
		2428	dup2 (fds [1], evpipe [1]);
		2429	close (fds [1]);
		2430	}
		2431
		2432	fd_intern (evpipe [1]);
		2433
		2434	ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
1840	ev_io_start (EV_A_ &pipe_w);	2435	ev_io_start (EV_A_ &pipe_w);
1841	ev_unref (EV_A); /* watcher should not keep loop alive */	2436	ev_unref (EV_A); /* watcher should not keep loop alive */
1842	}	2437	}
1843	}	2438	}
1844		2439
…		…
1849		2444
1850	if (expect_true (*flag))	2445	if (expect_true (*flag))
1851	return;	2446	return;
1852		2447
1853	*flag = 1;	2448	*flag = 1;
1854
1855	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */	2449	ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
1856		2450
1857	pipe_write_skipped = 1;	2451	pipe_write_skipped = 1;
1858		2452
1859	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */	2453	ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
1860		2454
1861	if (pipe_write_wanted)	2455	if (pipe_write_wanted)
1862	{	2456	{
1863	int old_errno;	2457	int old_errno;
1864		2458
1865	pipe_write_skipped = 0; /* just an optimisation, no fence needed */	2459	pipe_write_skipped = 0;
		2460	ECB_MEMORY_FENCE_RELEASE;
1866		2461
1867	old_errno = errno; /* save errno because write will clobber it */	2462	old_errno = errno; /* save errno because write will clobber it */
1868		2463
1869	#if EV_USE_EVENTFD	2464	#if EV_USE_EVENTFD
1870	if (evfd >= 0)	2465	if (evpipe [0] < 0)
1871	{	2466	{
1872	uint64_t counter = 1;	2467	uint64_t counter = 1;
1873	write (evfd, &counter, sizeof (uint64_t));	2468	write (evpipe [1], &counter, sizeof (uint64_t));
1874	}	2469	}
1875	else	2470	else
1876	#endif	2471	#endif
1877	{	2472	{
1878	#ifdef _WIN32	2473	#ifdef _WIN32
…		…
1898	int i;	2493	int i;
1899		2494
1900	if (revents & EV_READ)	2495	if (revents & EV_READ)
1901	{	2496	{
1902	#if EV_USE_EVENTFD	2497	#if EV_USE_EVENTFD
1903	if (evfd >= 0)	2498	if (evpipe [0] < 0)
1904	{	2499	{
1905	uint64_t counter;	2500	uint64_t counter;
1906	read (evfd, &counter, sizeof (uint64_t));	2501	read (evpipe [1], &counter, sizeof (uint64_t));
1907	}	2502	}
1908	else	2503	else
1909	#endif	2504	#endif
1910	{	2505	{
1911	char dummy[4];	2506	char dummy[4];
…		…
1929	#if EV_SIGNAL_ENABLE	2524	#if EV_SIGNAL_ENABLE
1930	if (sig_pending)	2525	if (sig_pending)
1931	{	2526	{
1932	sig_pending = 0;	2527	sig_pending = 0;
1933		2528
1934	ECB_MEMORY_FENCE_RELEASE;	2529	ECB_MEMORY_FENCE;
1935		2530
1936	for (i = EV_NSIG - 1; i--; )	2531	for (i = EV_NSIG - 1; i--; )
1937	if (expect_false (signals [i].pending))	2532	if (expect_false (signals [i].pending))
1938	ev_feed_signal_event (EV_A_ i + 1);	2533	ev_feed_signal_event (EV_A_ i + 1);
1939	}	2534	}
…		…
1942	#if EV_ASYNC_ENABLE	2537	#if EV_ASYNC_ENABLE
1943	if (async_pending)	2538	if (async_pending)
1944	{	2539	{
1945	async_pending = 0;	2540	async_pending = 0;
1946		2541
1947	ECB_MEMORY_FENCE_RELEASE;	2542	ECB_MEMORY_FENCE;
1948		2543
1949	for (i = asynccnt; i--; )	2544	for (i = asynccnt; i--; )
1950	if (asyncs [i]->sent)	2545	if (asyncs [i]->sent)
1951	{	2546	{
1952	asyncs [i]->sent = 0;	2547	asyncs [i]->sent = 0;
		2548	ECB_MEMORY_FENCE_RELEASE;
1953	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);	2549	ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
1954	}	2550	}
1955	}	2551	}
1956	#endif	2552	#endif
1957	}	2553	}
…		…
1960		2556
1961	void	2557	void
1962	ev_feed_signal (int signum) EV_THROW	2558	ev_feed_signal (int signum) EV_THROW
1963	{	2559	{
1964	#if EV_MULTIPLICITY	2560	#if EV_MULTIPLICITY
		2561	EV_P;
		2562	ECB_MEMORY_FENCE_ACQUIRE;
1965	EV_P = signals [signum - 1].loop;	2563	EV_A = signals [signum - 1].loop;
1966		2564
1967	if (!EV_A)	2565	if (!EV_A)
1968	return;	2566	return;
1969	#endif	2567	#endif
1970		2568
1971	if (!ev_active (&pipe_w))
1972	return;
1973
1974	signals [signum - 1].pending = 1;	2569	signals [signum - 1].pending = 1;
1975	evpipe_write (EV_A_ &sig_pending);	2570	evpipe_write (EV_A_ &sig_pending);
1976	}	2571	}
1977		2572
1978	static void	2573	static void
…		…
1983	#endif	2578	#endif
1984		2579
1985	ev_feed_signal (signum);	2580	ev_feed_signal (signum);
1986	}	2581	}
1987		2582
1988	void noinline	2583	noinline
		2584	void
1989	ev_feed_signal_event (EV_P_ int signum) EV_THROW	2585	ev_feed_signal_event (EV_P_ int signum) EV_THROW
1990	{	2586	{
1991	WL w;	2587	WL w;
1992		2588
1993	if (expect_false (signum <= 0 || signum > EV_NSIG))	2589	if (expect_false (signum <= 0 || signum >= EV_NSIG))
1994	return;	2590	return;
1995		2591
1996	--signum;	2592	--signum;
1997		2593
1998	#if EV_MULTIPLICITY	2594	#if EV_MULTIPLICITY
…		…
2002	if (expect_false (signals [signum].loop != EV_A))	2598	if (expect_false (signals [signum].loop != EV_A))
2003	return;	2599	return;
2004	#endif	2600	#endif
2005		2601
2006	signals [signum].pending = 0;	2602	signals [signum].pending = 0;
		2603	ECB_MEMORY_FENCE_RELEASE;
2007		2604
2008	for (w = signals [signum].head; w; w = w->next)	2605	for (w = signals [signum].head; w; w = w->next)
2009	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);	2606	ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2010	}	2607	}
2011		2608
…		…
2109	#endif	2706	#endif
2110	#if EV_USE_SELECT	2707	#if EV_USE_SELECT
2111	# include "ev_select.c"	2708	# include "ev_select.c"
2112	#endif	2709	#endif
2113		2710
2114	int ecb_cold	2711	ecb_cold int
2115	ev_version_major (void) EV_THROW	2712	ev_version_major (void) EV_THROW
2116	{	2713	{
2117	return EV_VERSION_MAJOR;	2714	return EV_VERSION_MAJOR;
2118	}	2715	}
2119		2716
2120	int ecb_cold	2717	ecb_cold int
2121	ev_version_minor (void) EV_THROW	2718	ev_version_minor (void) EV_THROW
2122	{	2719	{
2123	return EV_VERSION_MINOR;	2720	return EV_VERSION_MINOR;
2124	}	2721	}
2125		2722
2126	/* return true if we are running with elevated privileges and should ignore env variables */	2723	/* return true if we are running with elevated privileges and should ignore env variables */
2127	int inline_size ecb_cold	2724	inline_size ecb_cold int
2128	enable_secure (void)	2725	enable_secure (void)
2129	{	2726	{
2130	#ifdef _WIN32	2727	#ifdef _WIN32
2131	return 0;	2728	return 0;
2132	#else	2729	#else
2133	return getuid () != geteuid ()	2730	return getuid () != geteuid ()
2134	|| getgid () != getegid ();	2731	|| getgid () != getegid ();
2135	#endif	2732	#endif
2136	}	2733	}
2137		2734
2138	unsigned int ecb_cold	2735	ecb_cold
		2736	unsigned int
2139	ev_supported_backends (void) EV_THROW	2737	ev_supported_backends (void) EV_THROW
2140	{	2738	{
2141	unsigned int flags = 0;	2739	unsigned int flags = 0;
2142		2740
2143	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;	2741	if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
…		…
2147	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;	2745	if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
2148		2746
2149	return flags;	2747	return flags;
2150	}	2748	}
2151		2749
2152	unsigned int ecb_cold	2750	ecb_cold
		2751	unsigned int
2153	ev_recommended_backends (void) EV_THROW	2752	ev_recommended_backends (void) EV_THROW
2154	{	2753	{
2155	unsigned int flags = ev_supported_backends ();	2754	unsigned int flags = ev_supported_backends ();
2156		2755
2157	#ifndef __NetBSD__	2756	#ifndef __NetBSD__
…		…
2169	#endif	2768	#endif
2170		2769
2171	return flags;	2770	return flags;
2172	}	2771	}
2173		2772
2174	unsigned int ecb_cold	2773	ecb_cold
		2774	unsigned int
2175	ev_embeddable_backends (void) EV_THROW	2775	ev_embeddable_backends (void) EV_THROW
2176	{	2776	{
2177	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;	2777	int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2178		2778
2179	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */	2779	/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
…		…
2225	{	2825	{
2226	return userdata;	2826	return userdata;
2227	}	2827	}
2228		2828
2229	void	2829	void
2230	ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW	2830	ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW
2231	{	2831	{
2232	invoke_cb = invoke_pending_cb;	2832	invoke_cb = invoke_pending_cb;
2233	}	2833	}
2234		2834
2235	void	2835	void
…		…
2239	acquire_cb = acquire;	2839	acquire_cb = acquire;
2240	}	2840	}
2241	#endif	2841	#endif
2242		2842
2243	/* initialise a loop structure, must be zero-initialised */	2843	/* initialise a loop structure, must be zero-initialised */
2244	static void noinline ecb_cold	2844	noinline ecb_cold
		2845	static void
2245	loop_init (EV_P_ unsigned int flags) EV_THROW	2846	loop_init (EV_P_ unsigned int flags) EV_THROW
2246	{	2847	{
2247	if (!backend)	2848	if (!backend)
2248	{	2849	{
2249	origflags = flags;	2850	origflags = flags;
…		…
2295	#if EV_ASYNC_ENABLE	2896	#if EV_ASYNC_ENABLE
2296	async_pending = 0;	2897	async_pending = 0;
2297	#endif	2898	#endif
2298	pipe_write_skipped = 0;	2899	pipe_write_skipped = 0;
2299	pipe_write_wanted = 0;	2900	pipe_write_wanted = 0;
		2901	evpipe [0] = -1;
		2902	evpipe [1] = -1;
2300	#if EV_USE_INOTIFY	2903	#if EV_USE_INOTIFY
2301	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;	2904	fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2302	#endif	2905	#endif
2303	#if EV_USE_SIGNALFD	2906	#if EV_USE_SIGNALFD
2304	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;	2907	sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
…		…
2334	#endif	2937	#endif
2335	}	2938	}
2336	}	2939	}
2337		2940
2338	/* free up a loop structure */	2941	/* free up a loop structure */
2339	void ecb_cold	2942	ecb_cold
		2943	void
2340	ev_loop_destroy (EV_P)	2944	ev_loop_destroy (EV_P)
2341	{	2945	{
2342	int i;	2946	int i;
2343		2947
2344	#if EV_MULTIPLICITY	2948	#if EV_MULTIPLICITY
…		…
2367	if (ev_is_active (&pipe_w))	2971	if (ev_is_active (&pipe_w))
2368	{	2972	{
2369	/*ev_ref (EV_A);*/	2973	/*ev_ref (EV_A);*/
2370	/*ev_io_stop (EV_A_ &pipe_w);*/	2974	/*ev_io_stop (EV_A_ &pipe_w);*/
2371		2975
2372	#if EV_USE_EVENTFD
2373	if (evfd >= 0)
2374	close (evfd);
2375	#endif
2376
2377	if (evpipe [0] >= 0)
2378	{
2379	EV_WIN32_CLOSE_FD (evpipe [0]);	2976	if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2380	EV_WIN32_CLOSE_FD (evpipe [1]);	2977	if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2381	}
2382	}	2978	}
2383		2979
2384	#if EV_USE_SIGNALFD	2980	#if EV_USE_SIGNALFD
2385	if (ev_is_active (&sigfd_w))	2981	if (ev_is_active (&sigfd_w))
2386	close (sigfd);	2982	close (sigfd);
…		…
2472	#endif	3068	#endif
2473	#if EV_USE_INOTIFY	3069	#if EV_USE_INOTIFY
2474	infy_fork (EV_A);	3070	infy_fork (EV_A);
2475	#endif	3071	#endif
2476		3072
		3073	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2477	if (ev_is_active (&pipe_w))	3074	if (ev_is_active (&pipe_w) && postfork != 2)
2478	{	3075	{
2479	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */	3076	/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2480		3077
2481	ev_ref (EV_A);	3078	ev_ref (EV_A);
2482	ev_io_stop (EV_A_ &pipe_w);	3079	ev_io_stop (EV_A_ &pipe_w);
2483		3080
2484	#if EV_USE_EVENTFD
2485	if (evfd >= 0)
2486	close (evfd);
2487	#endif
2488
2489	if (evpipe [0] >= 0)	3081	if (evpipe [0] >= 0)
2490	{
2491	EV_WIN32_CLOSE_FD (evpipe [0]);	3082	EV_WIN32_CLOSE_FD (evpipe [0]);
2492	EV_WIN32_CLOSE_FD (evpipe [1]);
2493	}
2494		3083
2495	#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2496	evpipe_init (EV_A);	3084	evpipe_init (EV_A);
2497	/* now iterate over everything, in case we missed something */	3085	/* iterate over everything, in case we missed something before */
2498	pipecb (EV_A_ &pipe_w, EV_READ);	3086	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2499	#endif
2500	}	3087	}
		3088	#endif
2501		3089
2502	postfork = 0;	3090	postfork = 0;
2503	}	3091	}
2504		3092
2505	#if EV_MULTIPLICITY	3093	#if EV_MULTIPLICITY
2506		3094
		3095	ecb_cold
2507	struct ev_loop * ecb_cold	3096	struct ev_loop *
2508	ev_loop_new (unsigned int flags) EV_THROW	3097	ev_loop_new (unsigned int flags) EV_THROW
2509	{	3098	{
2510	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));	3099	EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2511		3100
2512	memset (EV_A, 0, sizeof (struct ev_loop));	3101	memset (EV_A, 0, sizeof (struct ev_loop));
…		…
2520	}	3109	}
2521		3110
2522	#endif /* multiplicity */	3111	#endif /* multiplicity */
2523		3112
2524	#if EV_VERIFY	3113	#if EV_VERIFY
2525	static void noinline ecb_cold	3114	noinline ecb_cold
		3115	static void
2526	verify_watcher (EV_P_ W w)	3116	verify_watcher (EV_P_ W w)
2527	{	3117	{
2528	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));	3118	assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2529		3119
2530	if (w->pending)	3120	if (w->pending)
2531	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));	3121	assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2532	}	3122	}
2533		3123
2534	static void noinline ecb_cold	3124	noinline ecb_cold
		3125	static void
2535	verify_heap (EV_P_ ANHE *heap, int N)	3126	verify_heap (EV_P_ ANHE *heap, int N)
2536	{	3127	{
2537	int i;	3128	int i;
2538		3129
2539	for (i = HEAP0; i < N + HEAP0; ++i)	3130	for (i = HEAP0; i < N + HEAP0; ++i)
…		…
2544		3135
2545	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));	3136	verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2546	}	3137	}
2547	}	3138	}
2548		3139
2549	static void noinline ecb_cold	3140	noinline ecb_cold
		3141	static void
2550	array_verify (EV_P_ W *ws, int cnt)	3142	array_verify (EV_P_ W *ws, int cnt)
2551	{	3143	{
2552	while (cnt--)	3144	while (cnt--)
2553	{	3145	{
2554	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));	3146	assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
…		…
2643	#endif	3235	#endif
2644	}	3236	}
2645	#endif	3237	#endif
2646		3238
2647	#if EV_MULTIPLICITY	3239	#if EV_MULTIPLICITY
		3240	ecb_cold
2648	struct ev_loop * ecb_cold	3241	struct ev_loop *
2649	#else	3242	#else
2650	int	3243	int
2651	#endif	3244	#endif
2652	ev_default_loop (unsigned int flags) EV_THROW	3245	ev_default_loop (unsigned int flags) EV_THROW
2653	{	3246	{
…		…
2678	}	3271	}
2679		3272
2680	void	3273	void
2681	ev_loop_fork (EV_P) EV_THROW	3274	ev_loop_fork (EV_P) EV_THROW
2682	{	3275	{
2683	postfork = 1; /* must be in line with ev_default_fork */	3276	postfork = 1;
2684	}	3277	}
2685		3278
2686	/*****************************************************************************/	3279	/*****************************************************************************/
2687		3280
2688	void	3281	void
…		…
2701	count += pendingcnt [pri];	3294	count += pendingcnt [pri];
2702		3295
2703	return count;	3296	return count;
2704	}	3297	}
2705		3298
2706	void noinline	3299	noinline
		3300	void
2707	ev_invoke_pending (EV_P)	3301	ev_invoke_pending (EV_P)
2708	{	3302	{
2709	for (pendingpri = NUMPRI; pendingpri--; ) /* pendingpri is modified during the loop */	3303	pendingpri = NUMPRI;
		3304
		3305	while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
		3306	{
		3307	--pendingpri;
		3308
2710	while (pendingcnt [pendingpri])	3309	while (pendingcnt [pendingpri])
2711	{	3310	{
2712	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];	3311	ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2713		3312
2714	p->w->pending = 0;	3313	p->w->pending = 0;
2715	EV_CB_INVOKE (p->w, p->events);	3314	EV_CB_INVOKE (p->w, p->events);
2716	EV_FREQUENT_CHECK;	3315	EV_FREQUENT_CHECK;
2717	}	3316	}
		3317	}
2718	}	3318	}
2719		3319
2720	#if EV_IDLE_ENABLE	3320	#if EV_IDLE_ENABLE
2721	/* make idle watchers pending. this handles the "call-idle */	3321	/* make idle watchers pending. this handles the "call-idle */
2722	/* only when higher priorities are idle" logic */	3322	/* only when higher priorities are idle" logic */
…		…
2780	}	3380	}
2781	}	3381	}
2782		3382
2783	#if EV_PERIODIC_ENABLE	3383	#if EV_PERIODIC_ENABLE
2784		3384
2785	static void noinline	3385	noinline
		3386	static void
2786	periodic_recalc (EV_P_ ev_periodic *w)	3387	periodic_recalc (EV_P_ ev_periodic *w)
2787	{	3388	{
2788	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;	3389	ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
2789	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);	3390	ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
2790		3391
…		…
2848	}	3449	}
2849	}	3450	}
2850		3451
2851	/* simply recalculate all periodics */	3452	/* simply recalculate all periodics */
2852	/* TODO: maybe ensure that at least one event happens when jumping forward? */	3453	/* TODO: maybe ensure that at least one event happens when jumping forward? */
2853	static void noinline ecb_cold	3454	noinline ecb_cold
		3455	static void
2854	periodics_reschedule (EV_P)	3456	periodics_reschedule (EV_P)
2855	{	3457	{
2856	int i;	3458	int i;
2857		3459
2858	/* adjust periodics after time jump */	3460	/* adjust periodics after time jump */
…		…
2871	reheap (periodics, periodiccnt);	3473	reheap (periodics, periodiccnt);
2872	}	3474	}
2873	#endif	3475	#endif
2874		3476
2875	/* adjust all timers by a given offset */	3477	/* adjust all timers by a given offset */
2876	static void noinline ecb_cold	3478	noinline ecb_cold
		3479	static void
2877	timers_reschedule (EV_P_ ev_tstamp adjust)	3480	timers_reschedule (EV_P_ ev_tstamp adjust)
2878	{	3481	{
2879	int i;	3482	int i;
2880		3483
2881	for (i = 0; i < timercnt; ++i)	3484	for (i = 0; i < timercnt; ++i)
…		…
3080	backend_poll (EV_A_ waittime);	3683	backend_poll (EV_A_ waittime);
3081	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */	3684	assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3082		3685
3083	pipe_write_wanted = 0; /* just an optimisation, no fence needed */	3686	pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3084		3687
		3688	ECB_MEMORY_FENCE_ACQUIRE;
3085	if (pipe_write_skipped)	3689	if (pipe_write_skipped)
3086	{	3690	{
3087	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));	3691	assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3088	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);	3692	ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3089	}	3693	}
…		…
3248	w->active = 0;	3852	w->active = 0;
3249	}	3853	}
3250		3854
3251	/*****************************************************************************/	3855	/*****************************************************************************/
3252		3856
3253	void noinline	3857	noinline
		3858	void
3254	ev_io_start (EV_P_ ev_io *w) EV_THROW	3859	ev_io_start (EV_P_ ev_io *w) EV_THROW
3255	{	3860	{
3256	int fd = w->fd;	3861	int fd = w->fd;
3257		3862
3258	if (expect_false (ev_is_active (w)))	3863	if (expect_false (ev_is_active (w)))
…		…
3274	w->events &= ~EV__IOFDSET;	3879	w->events &= ~EV__IOFDSET;
3275		3880
3276	EV_FREQUENT_CHECK;	3881	EV_FREQUENT_CHECK;
3277	}	3882	}
3278		3883
3279	void noinline	3884	noinline
		3885	void
3280	ev_io_stop (EV_P_ ev_io *w) EV_THROW	3886	ev_io_stop (EV_P_ ev_io *w) EV_THROW
3281	{	3887	{
3282	clear_pending (EV_A_ (W)w);	3888	clear_pending (EV_A_ (W)w);
3283	if (expect_false (!ev_is_active (w)))	3889	if (expect_false (!ev_is_active (w)))
3284	return;	3890	return;
…		…
3293	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);	3899	fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3294		3900
3295	EV_FREQUENT_CHECK;	3901	EV_FREQUENT_CHECK;
3296	}	3902	}
3297		3903
3298	void noinline	3904	noinline
		3905	void
3299	ev_timer_start (EV_P_ ev_timer *w) EV_THROW	3906	ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3300	{	3907	{
3301	if (expect_false (ev_is_active (w)))	3908	if (expect_false (ev_is_active (w)))
3302	return;	3909	return;
3303		3910
…		…
3317	EV_FREQUENT_CHECK;	3924	EV_FREQUENT_CHECK;
3318		3925
3319	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/	3926	/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3320	}	3927	}
3321		3928
3322	void noinline	3929	noinline
		3930	void
3323	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW	3931	ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3324	{	3932	{
3325	clear_pending (EV_A_ (W)w);	3933	clear_pending (EV_A_ (W)w);
3326	if (expect_false (!ev_is_active (w)))	3934	if (expect_false (!ev_is_active (w)))
3327	return;	3935	return;
…		…
3347	ev_stop (EV_A_ (W)w);	3955	ev_stop (EV_A_ (W)w);
3348		3956
3349	EV_FREQUENT_CHECK;	3957	EV_FREQUENT_CHECK;
3350	}	3958	}
3351		3959
3352	void noinline	3960	noinline
		3961	void
3353	ev_timer_again (EV_P_ ev_timer *w) EV_THROW	3962	ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3354	{	3963	{
3355	EV_FREQUENT_CHECK;	3964	EV_FREQUENT_CHECK;
3356		3965
3357	clear_pending (EV_A_ (W)w);	3966	clear_pending (EV_A_ (W)w);
…		…
3381	{	3990	{
3382	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);	3991	return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3383	}	3992	}
3384		3993
3385	#if EV_PERIODIC_ENABLE	3994	#if EV_PERIODIC_ENABLE
3386	void noinline	3995	noinline
		3996	void
3387	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW	3997	ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3388	{	3998	{
3389	if (expect_false (ev_is_active (w)))	3999	if (expect_false (ev_is_active (w)))
3390	return;	4000	return;
3391		4001
…		…
3411	EV_FREQUENT_CHECK;	4021	EV_FREQUENT_CHECK;
3412		4022
3413	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/	4023	/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3414	}	4024	}
3415		4025
3416	void noinline	4026	noinline
		4027	void
3417	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW	4028	ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3418	{	4029	{
3419	clear_pending (EV_A_ (W)w);	4030	clear_pending (EV_A_ (W)w);
3420	if (expect_false (!ev_is_active (w)))	4031	if (expect_false (!ev_is_active (w)))
3421	return;	4032	return;
…		…
3439	ev_stop (EV_A_ (W)w);	4050	ev_stop (EV_A_ (W)w);
3440		4051
3441	EV_FREQUENT_CHECK;	4052	EV_FREQUENT_CHECK;
3442	}	4053	}
3443		4054
3444	void noinline	4055	noinline
		4056	void
3445	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW	4057	ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3446	{	4058	{
3447	/* TODO: use adjustheap and recalculation */	4059	/* TODO: use adjustheap and recalculation */
3448	ev_periodic_stop (EV_A_ w);	4060	ev_periodic_stop (EV_A_ w);
3449	ev_periodic_start (EV_A_ w);	4061	ev_periodic_start (EV_A_ w);
…		…
3454	# define SA_RESTART 0	4066	# define SA_RESTART 0
3455	#endif	4067	#endif
3456		4068
3457	#if EV_SIGNAL_ENABLE	4069	#if EV_SIGNAL_ENABLE
3458		4070
3459	void noinline	4071	noinline
		4072	void
3460	ev_signal_start (EV_P_ ev_signal *w) EV_THROW	4073	ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3461	{	4074	{
3462	if (expect_false (ev_is_active (w)))	4075	if (expect_false (ev_is_active (w)))
3463	return;	4076	return;
3464		4077
…		…
3467	#if EV_MULTIPLICITY	4080	#if EV_MULTIPLICITY
3468	assert (("libev: a signal must not be attached to two different loops",	4081	assert (("libev: a signal must not be attached to two different loops",
3469	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));	4082	!signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3470		4083
3471	signals [w->signum - 1].loop = EV_A;	4084	signals [w->signum - 1].loop = EV_A;
		4085	ECB_MEMORY_FENCE_RELEASE;
3472	#endif	4086	#endif
3473		4087
3474	EV_FREQUENT_CHECK;	4088	EV_FREQUENT_CHECK;
3475		4089
3476	#if EV_USE_SIGNALFD	4090	#if EV_USE_SIGNALFD
…		…
3535	}	4149	}
3536		4150
3537	EV_FREQUENT_CHECK;	4151	EV_FREQUENT_CHECK;
3538	}	4152	}
3539		4153
3540	void noinline	4154	noinline
		4155	void
3541	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW	4156	ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3542	{	4157	{
3543	clear_pending (EV_A_ (W)w);	4158	clear_pending (EV_A_ (W)w);
3544	if (expect_false (!ev_is_active (w)))	4159	if (expect_false (!ev_is_active (w)))
3545	return;	4160	return;
…		…
3621		4236
3622	#define DEF_STAT_INTERVAL 5.0074891	4237	#define DEF_STAT_INTERVAL 5.0074891
3623	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */	4238	#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
3624	#define MIN_STAT_INTERVAL 0.1074891	4239	#define MIN_STAT_INTERVAL 0.1074891
3625		4240
3626	static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);	4241	noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
3627		4242
3628	#if EV_USE_INOTIFY	4243	#if EV_USE_INOTIFY
3629		4244
3630	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */	4245	/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
3631	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)	4246	# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3632		4247
3633	static void noinline	4248	noinline
		4249	static void
3634	infy_add (EV_P_ ev_stat *w)	4250	infy_add (EV_P_ ev_stat *w)
3635	{	4251	{
3636	w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD);	4252	w->wd = inotify_add_watch (fs_fd, w->path,
		4253	IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
		4254	| IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
		4255	| IN_DONT_FOLLOW | IN_MASK_ADD);
3637		4256
3638	if (w->wd >= 0)	4257	if (w->wd >= 0)
3639	{	4258	{
3640	struct statfs sfs;	4259	struct statfs sfs;
3641		4260
…		…
3645		4264
3646	if (!fs_2625)	4265	if (!fs_2625)
3647	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;	4266	w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3648	else if (!statfs (w->path, &sfs)	4267	else if (!statfs (w->path, &sfs)
3649	&& (sfs.f_type == 0x1373 /* devfs */	4268	&& (sfs.f_type == 0x1373 /* devfs */
		4269	|| sfs.f_type == 0x4006 /* fat */
		4270	|| sfs.f_type == 0x4d44 /* msdos */
3650	|| sfs.f_type == 0xEF53 /* ext2/3 */	4271	|| sfs.f_type == 0xEF53 /* ext2/3 */
		4272	|| sfs.f_type == 0x72b6 /* jffs2 */
		4273	|| sfs.f_type == 0x858458f6 /* ramfs */
		4274	|| sfs.f_type == 0x5346544e /* ntfs */
3651	|| sfs.f_type == 0x3153464a /* jfs */	4275	|| sfs.f_type == 0x3153464a /* jfs */
		4276	|| sfs.f_type == 0x9123683e /* btrfs */
3652	|| sfs.f_type == 0x52654973 /* reiser3 */	4277	|| sfs.f_type == 0x52654973 /* reiser3 */
3653	|| sfs.f_type == 0x01021994 /* tempfs */	4278	|| sfs.f_type == 0x01021994 /* tmpfs */
3654	|| sfs.f_type == 0x58465342 /* xfs */))	4279	|| sfs.f_type == 0x58465342 /* xfs */))
3655	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */	4280	w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3656	else	4281	else
3657	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */	4282	w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3658	}	4283	}
…		…
3693	if (ev_is_active (&w->timer)) ev_ref (EV_A);	4318	if (ev_is_active (&w->timer)) ev_ref (EV_A);
3694	ev_timer_again (EV_A_ &w->timer);	4319	ev_timer_again (EV_A_ &w->timer);
3695	if (ev_is_active (&w->timer)) ev_unref (EV_A);	4320	if (ev_is_active (&w->timer)) ev_unref (EV_A);
3696	}	4321	}
3697		4322
3698	static void noinline	4323	noinline
		4324	static void
3699	infy_del (EV_P_ ev_stat *w)	4325	infy_del (EV_P_ ev_stat *w)
3700	{	4326	{
3701	int slot;	4327	int slot;
3702	int wd = w->wd;	4328	int wd = w->wd;
3703		4329
…		…
3710		4336
3711	/* remove this watcher, if others are watching it, they will rearm */	4337	/* remove this watcher, if others are watching it, they will rearm */
3712	inotify_rm_watch (fs_fd, wd);	4338	inotify_rm_watch (fs_fd, wd);
3713	}	4339	}
3714		4340
3715	static void noinline	4341	noinline
		4342	static void
3716	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)	4343	infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
3717	{	4344	{
3718	if (slot < 0)	4345	if (slot < 0)
3719	/* overflow, need to check for all hash slots */	4346	/* overflow, need to check for all hash slots */
3720	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)	4347	for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
…		…
3756	infy_wd (EV_A_ ev->wd, ev->wd, ev);	4383	infy_wd (EV_A_ ev->wd, ev->wd, ev);
3757	ofs += sizeof (struct inotify_event) + ev->len;	4384	ofs += sizeof (struct inotify_event) + ev->len;
3758	}	4385	}
3759	}	4386	}
3760		4387
3761	inline_size void ecb_cold	4388	inline_size ecb_cold
		4389	void
3762	ev_check_2625 (EV_P)	4390	ev_check_2625 (EV_P)
3763	{	4391	{
3764	/* kernels < 2.6.25 are borked	4392	/* kernels < 2.6.25 are borked
3765	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html	4393	* http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
3766	*/	4394	*/
…		…
3864	w->attr.st_nlink = 0;	4492	w->attr.st_nlink = 0;
3865	else if (!w->attr.st_nlink)	4493	else if (!w->attr.st_nlink)
3866	w->attr.st_nlink = 1;	4494	w->attr.st_nlink = 1;
3867	}	4495	}
3868		4496
3869	static void noinline	4497	noinline
		4498	static void
3870	stat_timer_cb (EV_P_ ev_timer *w_, int revents)	4499	stat_timer_cb (EV_P_ ev_timer *w_, int revents)
3871	{	4500	{
3872	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));	4501	ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
3873		4502
3874	ev_statdata prev = w->attr;	4503	ev_statdata prev = w->attr;
…		…
4084	EV_FREQUENT_CHECK;	4713	EV_FREQUENT_CHECK;
4085	}	4714	}
4086	#endif	4715	#endif
4087		4716
4088	#if EV_EMBED_ENABLE	4717	#if EV_EMBED_ENABLE
4089	void noinline	4718	noinline
		4719	void
4090	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW	4720	ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4091	{	4721	{
4092	ev_run (w->other, EVRUN_NOWAIT);	4722	ev_run (w->other, EVRUN_NOWAIT);
4093	}	4723	}
4094		4724
…		…
4391	}	5021	}
4392		5022
4393	/*****************************************************************************/	5023	/*****************************************************************************/
4394		5024
4395	#if EV_WALK_ENABLE	5025	#if EV_WALK_ENABLE
4396	void ecb_cold	5026	ecb_cold
		5027	void
4397	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW	5028	ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4398	{	5029	{
4399	int i, j;	5030	int i, j;
4400	ev_watcher_list *wl, *wn;	5031	ev_watcher_list *wl, *wn;
4401		5032

Diff Legend

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