summaryrefslogtreecommitdiff
path: root/ev.c
diff options
context:
space:
mode:
authorMarc Alexander Lehmann <libev@schmorp.de>2015-02-11 19:20:21 +0000
committerMarc Alexander Lehmann <libev@schmorp.de>2015-02-11 19:20:21 +0000
commit0682668768a1666edc0b77659e1094e24626220a (patch)
treeae0b86016df7a640d6e87c3eb022d22211a5a3af /ev.c
parenta5f210671eff89d2a9ef38519b1f6e2200f9b220 (diff)
downloadlibev-0682668768a1666edc0b77659e1094e24626220a.tar.gz
libev-0682668768a1666edc0b77659e1094e24626220a.zip
*** empty log message ***
Diffstat (limited to 'ev.c')
-rw-r--r--ev.c236
1 files changed, 133 insertions, 103 deletions
diff --git a/ev.c b/ev.c
index 6f36c6d..b92ac15 100644
--- a/ev.c
+++ b/ev.c
@@ -493,7 +493,7 @@ struct signalfd_siginfo
/*
* libecb - http://software.schmorp.de/pkg/libecb
*
- * Copyright (©) 2009-2014 Marc Alexander Lehmann <libecb@schmorp.de>
+ * Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
* Copyright (©) 2011 Emanuele Giaquinta
* All rights reserved.
*
@@ -534,7 +534,7 @@ struct signalfd_siginfo
#define ECB_H
/* 16 bits major, 16 bits minor */
-#define ECB_VERSION 0x00010003
+#define ECB_VERSION 0x00010004
#ifdef _WIN32
typedef signed char int8_t;
@@ -584,12 +584,24 @@ struct signalfd_siginfo
* we try to detect these and simply assume they are not gcc - if they have
* an issue with that they should have done it right in the first place.
*/
-#ifndef ECB_GCC_VERSION
- #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
- #define ECB_GCC_VERSION(major,minor) 0
- #else
- #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
- #endif
+#if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
+ #define ECB_GCC_VERSION(major,minor) 0
+#else
+ #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
+#endif
+
+#define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
+
+#if __clang__ && defined __has_builtin
+ #define ECB_CLANG_BUILTIN(x) __has_builtin (x)
+#else
+ #define ECB_CLANG_BUILTIN(x) 0
+#endif
+
+#if __clang__ && defined __has_extension
+ #define ECB_CLANG_EXTENSION(x) __has_extension (x)
+#else
+ #define ECB_CLANG_EXTENSION(x) 0
#endif
#define ECB_CPP (__cplusplus+0)
@@ -683,16 +695,11 @@ struct signalfd_siginfo
#define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
#define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
- /* The __has_feature syntax from clang is so misdesigned that we cannot use it
- * without risking compile time errors with other compilers. We *could*
- * define our own ecb_clang_has_feature, but I just can't be bothered to work
- * around this shit time and again.
- * #elif defined __clang && __has_feature (cxx_atomic)
- * // see comment below (stdatomic.h) about the C11 memory model.
- * #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
- * #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
- * #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
- */
+ #elif ECB_CLANG_EXTENSION(c_atomic)
+ /* see comment below (stdatomic.h) about the C11 memory model. */
+ #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
+ #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
+ #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
#elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
#define ECB_MEMORY_FENCE __sync_synchronize ()
@@ -765,7 +772,7 @@ struct signalfd_siginfo
/*****************************************************************************/
-#if __cplusplus
+#if ECB_CPP
#define ecb_inline static inline
#elif ECB_GCC_VERSION(2,5)
#define ecb_inline static __inline__
@@ -792,32 +799,45 @@ typedef int ecb_bool;
#define ecb_function_ ecb_inline
-#if ECB_GCC_VERSION(3,1)
- #define ecb_attribute(attrlist) __attribute__(attrlist)
- #define ecb_is_constant(expr) __builtin_constant_p (expr)
- #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
- #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
+#if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
+ #define ecb_attribute(attrlist) __attribute__ (attrlist)
#else
#define ecb_attribute(attrlist)
+#endif
+#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
+ #define ecb_is_constant(expr) __builtin_constant_p (expr)
+#else
/* possible C11 impl for integral types
typedef struct ecb_is_constant_struct ecb_is_constant_struct;
#define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
#define ecb_is_constant(expr) 0
+#endif
+
+#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
+ #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
+#else
#define ecb_expect(expr,value) (expr)
+#endif
+
+#if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
+ #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
+#else
#define ecb_prefetch(addr,rw,locality)
#endif
/* no emulation for ecb_decltype */
-#if ECB_GCC_VERSION(4,5)
- #define ecb_decltype(x) __decltype(x)
-#elif ECB_GCC_VERSION(3,0)
- #define ecb_decltype(x) __typeof(x)
+#if ECB_CPP11
+ // older implementations might have problems with decltype(x)::type, work around it
+ template<class T> struct ecb_decltype_t { typedef T type; };
+ #define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
+#elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
+ #define ecb_decltype(x) __typeof__ (x)
#endif
#if _MSC_VER >= 1300
- #define ecb_deprecated __declspec(deprecated)
+ #define ecb_deprecated __declspec (deprecated)
#else
#define ecb_deprecated ecb_attribute ((__deprecated__))
#endif
@@ -827,8 +847,9 @@ typedef int ecb_bool;
#define ecb_const ecb_attribute ((__const__))
#define ecb_pure ecb_attribute ((__pure__))
-/* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx __declspec(noreturn) */
-#if ECB_C11
+/* TODO http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx __declspec(noreturn) */
+#if ECB_C11 || __IBMC_NORETURN
+ /* http://pic.dhe.ibm.com/infocenter/compbg/v121v141/topic/com.ibm.xlcpp121.bg.doc/language_ref/noreturn.html */
#define ecb_noreturn _Noreturn
#else
#define ecb_noreturn ecb_attribute ((__noreturn__))
@@ -854,7 +875,10 @@ typedef int ecb_bool;
#define ecb_unlikely(expr) ecb_expect_false (expr)
/* count trailing zero bits and count # of one bits */
-#if ECB_GCC_VERSION(3,4)
+#if ECB_GCC_VERSION(3,4) \
+ || (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
+ && ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
+ && ECB_CLANG_BUILTIN(__builtin_popcount))
/* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
#define ecb_ld32(x) (__builtin_clz (x) ^ 31)
#define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
@@ -863,8 +887,8 @@ typedef int ecb_bool;
#define ecb_popcount32(x) __builtin_popcount (x)
/* no popcountll */
#else
- ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
- ecb_function_ int
+ ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
+ ecb_function_ ecb_const int
ecb_ctz32 (uint32_t x)
{
int r = 0;
@@ -888,16 +912,16 @@ typedef int ecb_bool;
return r;
}
- ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
- ecb_function_ int
+ ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
+ ecb_function_ ecb_const int
ecb_ctz64 (uint64_t x)
{
int shift = x & 0xffffffffU ? 0 : 32;
return ecb_ctz32 (x >> shift) + shift;
}
- ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
- ecb_function_ int
+ ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
+ ecb_function_ ecb_const int
ecb_popcount32 (uint32_t x)
{
x -= (x >> 1) & 0x55555555;
@@ -908,8 +932,8 @@ typedef int ecb_bool;
return x >> 24;
}
- ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
- ecb_function_ int ecb_ld32 (uint32_t x)
+ ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
+ ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
{
int r = 0;
@@ -922,8 +946,8 @@ typedef int ecb_bool;
return r;
}
- ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
- ecb_function_ int ecb_ld64 (uint64_t x)
+ ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
+ ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
{
int r = 0;
@@ -933,20 +957,20 @@ typedef int ecb_bool;
}
#endif
-ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
-ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
-ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
-ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
+ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
+ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
+ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
+ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
-ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
-ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
+ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
+ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
{
return ( (x * 0x0802U & 0x22110U)
- | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
+ | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
}
-ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;
-ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
+ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
+ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
{
x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
@@ -956,8 +980,8 @@ ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
return x;
}
-ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;
-ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
+ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
+ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
{
x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
@@ -970,71 +994,71 @@ ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
/* popcount64 is only available on 64 bit cpus as gcc builtin */
/* so for this version we are lazy */
-ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
-ecb_function_ int
+ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
+ecb_function_ ecb_const int
ecb_popcount64 (uint64_t x)
{
return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
}
-ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;
-ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;
-ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
-ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
-ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
-ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
-ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
-ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
-
-ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
-ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
-ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
-ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
-ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
-ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
-ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
-ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
-
-#if ECB_GCC_VERSION(4,3)
+ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
+ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
+ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
+ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
+ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
+ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
+ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
+ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
+
+ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
+ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
+ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
+ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
+ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
+ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
+ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
+ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
+
+#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
#define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
#define ecb_bswap32(x) __builtin_bswap32 (x)
#define ecb_bswap64(x) __builtin_bswap64 (x)
#else
- ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
- ecb_function_ uint16_t
+ ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
+ ecb_function_ ecb_const uint16_t
ecb_bswap16 (uint16_t x)
{
return ecb_rotl16 (x, 8);
}
- ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
- ecb_function_ uint32_t
+ ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
+ ecb_function_ ecb_const uint32_t
ecb_bswap32 (uint32_t x)
{
return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
}
- ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
- ecb_function_ uint64_t
+ ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
+ ecb_function_ ecb_const uint64_t
ecb_bswap64 (uint64_t x)
{
return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
}
#endif
-#if ECB_GCC_VERSION(4,5)
+#if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
#define ecb_unreachable() __builtin_unreachable ()
#else
/* this seems to work fine, but gcc always emits a warning for it :/ */
- ecb_inline void ecb_unreachable (void) ecb_noreturn;
- ecb_inline void ecb_unreachable (void) { }
+ ecb_inline ecb_noreturn void ecb_unreachable (void);
+ ecb_inline ecb_noreturn void ecb_unreachable (void) { }
#endif
/* try to tell the compiler that some condition is definitely true */
#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
-ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
-ecb_inline unsigned char
+ecb_inline ecb_const unsigned char ecb_byteorder_helper (void);
+ecb_inline ecb_const unsigned char
ecb_byteorder_helper (void)
{
/* the union code still generates code under pressure in gcc, */
@@ -1059,10 +1083,10 @@ ecb_byteorder_helper (void)
#endif
}
-ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
-ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
-ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
-ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
+ecb_inline ecb_const ecb_bool ecb_big_endian (void);
+ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
+ecb_inline ecb_const ecb_bool ecb_little_endian (void);
+ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
#if ECB_GCC_VERSION(3,0) || ECB_C99
#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
@@ -1070,7 +1094,7 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
#define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
#endif
-#if __cplusplus
+#if ECB_CPP
template<typename T>
static inline T ecb_div_rd (T val, T div)
{
@@ -1140,17 +1164,23 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
#define ECB_NAN ECB_INFINITY
#endif
+ #if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
+ #define ecb_ldexpf(x,e) ldexpf ((x), (e))
+ #else
+ #define ecb_ldexpf(x,e) (float) ldexp ((x), (e))
+ #endif
+
/* converts an ieee half/binary16 to a float */
- ecb_function_ float ecb_binary16_to_float (uint16_t x) ecb_const;
- ecb_function_ float
+ ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
+ ecb_function_ ecb_const float
ecb_binary16_to_float (uint16_t x)
{
int e = (x >> 10) & 0x1f;
int m = x & 0x3ff;
float r;
- if (!e ) r = ldexpf (m , -24);
- else if (e != 31) r = ldexpf (m + 0x400, e - 25);
+ if (!e ) r = ecb_ldexpf (m , -24);
+ else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
else if (m ) r = ECB_NAN;
else r = ECB_INFINITY;
@@ -1158,8 +1188,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
}
/* convert a float to ieee single/binary32 */
- ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
- ecb_function_ uint32_t
+ ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
+ ecb_function_ ecb_const uint32_t
ecb_float_to_binary32 (float x)
{
uint32_t r;
@@ -1198,8 +1228,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
}
/* converts an ieee single/binary32 to a float */
- ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
- ecb_function_ float
+ ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
+ ecb_function_ ecb_const float
ecb_binary32_to_float (uint32_t x)
{
float r;
@@ -1219,7 +1249,7 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
e = 1;
/* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
- r = ldexpf (x * (0.5f / 0x800000U), e - 126);
+ r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
r = neg ? -r : r;
#endif
@@ -1228,8 +1258,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
}
/* convert a double to ieee double/binary64 */
- ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
- ecb_function_ uint64_t
+ ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
+ ecb_function_ ecb_const uint64_t
ecb_double_to_binary64 (double x)
{
uint64_t r;
@@ -1268,8 +1298,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
}
/* converts an ieee double/binary64 to a double */
- ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
- ecb_function_ double
+ ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
+ ecb_function_ ecb_const double
ecb_binary64_to_double (uint64_t x)
{
double r;