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

Comparing libecb/ecb.h (file contents):
Revision 1.186 by root, Tue Jan 21 23:51:21 2020 UTC vs.
Revision 1.192 by root, Mon Jun 21 23:59:58 2021 UTC

1/* 1/*
2 * libecb - http://software.schmorp.de/pkg/libecb 2 * libecb - http://software.schmorp.de/pkg/libecb
3 * 3 *
4 * Copyright (©) 2009-2015,2018-2020 Marc Alexander Lehmann <libecb@schmorp.de> 4 * Copyright (©) 2009-2015,2018-2021 Marc Alexander Lehmann <libecb@schmorp.de>
5 * Copyright (©) 2011 Emanuele Giaquinta 5 * Copyright (©) 2011 Emanuele Giaquinta
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without modifica- 8 * Redistribution and use in source and binary forms, with or without modifica-
9 * tion, are permitted provided that the following conditions are met: 9 * tion, are permitted provided that the following conditions are met:
… …
40 40
41#ifndef ECB_H 41#ifndef ECB_H
42#define ECB_H 42#define ECB_H
43 43
44/* 16 bits major, 16 bits minor */ 44/* 16 bits major, 16 bits minor */
45#define ECB_VERSION 0x00010008 45#define ECB_VERSION 0x00010009
46 46
47#include <string.h> /* for memcpy */ 47#include <string.h> /* for memcpy */
48 48
49#ifdef _WIN32 49#if defined (_WIN32) && !defined (__MINGW32__)
50 typedef signed char int8_t; 50 typedef signed char int8_t;
51 typedef unsigned char uint8_t; 51 typedef unsigned char uint8_t;
52 typedef signed char int_fast8_t; 52 typedef signed char int_fast8_t;
53 typedef unsigned char uint_fast8_t; 53 typedef unsigned char uint_fast8_t;
54 typedef signed short int16_t; 54 typedef signed short int16_t;
… …
102 #if _ILP32 102 #if _ILP32
103 #define ECB_AMD64_X32 1 103 #define ECB_AMD64_X32 1
104 #else 104 #else
105 #define ECB_AMD64 1 105 #define ECB_AMD64 1
106 #endif 106 #endif
107#endif
108
109#if ECB_PTRSIZE >= 8 || ECB_AMD64_X32
110 #define ECB_64BIT_NATIVE 1
111#else
112 #define ECB_64BIT_NATIVE 0
107#endif 113#endif
108 114
109/* many compilers define _GNUC_ to some versions but then only implement 115/* many compilers define _GNUC_ to some versions but then only implement
110 * what their idiot authors think are the "more important" extensions, 116 * what their idiot authors think are the "more important" extensions,
111 * causing enormous grief in return for some better fake benchmark numbers. 117 * causing enormous grief in return for some better fake benchmark numbers.
… …
242 #if ECB_GCC_VERSION(4,7) 248 #if ECB_GCC_VERSION(4,7)
243 /* see comment below (stdatomic.h) about the C11 memory model. */ 249 /* see comment below (stdatomic.h) about the C11 memory model. */
244 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 250 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
245 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE) 251 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
246 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE) 252 #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
253 #undef ECB_MEMORY_FENCE_RELAXED
247 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED) 254 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
248 255
249 #elif ECB_CLANG_EXTENSION(c_atomic) 256 #elif ECB_CLANG_EXTENSION(c_atomic)
250 /* see comment below (stdatomic.h) about the C11 memory model. */ 257 /* see comment below (stdatomic.h) about the C11 memory model. */
251 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 258 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
252 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE) 259 #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
253 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE) 260 #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
261 #undef ECB_MEMORY_FENCE_RELAXED
254 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED) 262 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
255 263
256 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 264 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
257 #define ECB_MEMORY_FENCE __sync_synchronize () 265 #define ECB_MEMORY_FENCE __sync_synchronize ()
258 #elif _MSC_VER >= 1500 /* VC++ 2008 */ 266 #elif _MSC_VER >= 1500 /* VC++ 2008 */
… …
799template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); } 807template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
800 808
801#endif 809#endif
802 810
803/*****************************************************************************/ 811/*****************************************************************************/
812/* division */
804 813
805#if ECB_GCC_VERSION(3,0) || ECB_C99 814#if ECB_GCC_VERSION(3,0) || ECB_C99
815 /* C99 tightened the definition of %, so we can use a more efficient version */
806 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0)) 816 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
807#else 817#else
808 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n))) 818 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
809#endif 819#endif
810 820
… …
821 } 831 }
822#else 832#else
823 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div)) 833 #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
824 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div)) 834 #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
825#endif 835#endif
836
837/*****************************************************************************/
838/* array length */
826 839
827#if ecb_cplusplus_does_not_suck 840#if ecb_cplusplus_does_not_suck
828 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */ 841 /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
829 template<typename T, int N> 842 template<typename T, int N>
830 static inline int ecb_array_length (const T (&arr)[N]) 843 static inline int ecb_array_length (const T (&arr)[N])
… …
834#else 847#else
835 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 848 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
836#endif 849#endif
837 850
838/*****************************************************************************/ 851/*****************************************************************************/
852/* IEEE 754-2008 half float conversions */
839 853
840ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x); 854ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
841ecb_function_ ecb_const uint32_t 855ecb_function_ ecb_const uint32_t
842ecb_binary16_to_binary32 (uint32_t x) 856ecb_binary16_to_binary32 (uint32_t x)
843{ 857{
… …
872ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x); 886ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
873ecb_function_ ecb_const uint16_t 887ecb_function_ ecb_const uint16_t
874ecb_binary32_to_binary16 (uint32_t x) 888ecb_binary32_to_binary16 (uint32_t x)
875{ 889{
876 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */ 890 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
877 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */ 891 int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
878 unsigned int m = x & 0x007fffff; 892 unsigned int m = x & 0x007fffff;
879 893
880 x &= 0x7fffffff; 894 x &= 0x7fffffff;
881 895
882 /* if it's within range of binary16 normals, use fast path */ 896 /* if it's within range of binary16 normals, use fast path */
… …
929 943
930 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */ 944 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
931 m >>= 13; 945 m >>= 13;
932 946
933 return s | 0x7c00 | m | !m; 947 return s | 0x7c00 | m | !m;
948}
949
950/*******************************************************************************/
951/* fast integer to ascii */
952
953// simply return a mask with "bits" bits set
954#define ecb_i2a_mask(type,bits) ((((type)1) << (bits)) - 1)
955
956// oputput a single digit. maskvalue is 10**digitidx
957#define ecb_i2a_digit(type,bits,digitmask,maskvalue,digitidx) \
958 if (digitmask >= maskvalue) /* constant, used to decide how many digits to generate */ \
959 { \
960 char digit = x >> (bits - digitidx); /* calculate the topmost digit */ \
961 *ptr = digit + '0'; /* output it */ \
962 nz = (digitmask == maskvalue) || nz || digit; /* first term == always output last digit */ \
963 ptr += nz; /* output digit only if non-zero digit seen */ \
964 x = (x & ecb_i2a_mask (type, bits - digitidx)) * 5; /* *10, but shift decimal point right */ \
965 }
966
967// convert integer to fixed point format and multiply out digits, highest first
968// requires magic constants: max. digits and number of bits after the decimal point
969#define ecb_i2a_def(suffix,ptr,v,type,bits,digitmask,lz) \
970ecb_inline char *ecb_i2a_ ## suffix (char *ptr, uint32_t u) \
971{ \
972 char nz = lz; /* non-zero digit seen? */ \
973 /* convert to x.bits fixed-point */ \
974 type x = u * ((ecb_i2a_mask (type, bits) + digitmask) / digitmask); \
975 /* output up to 10 digits */ \
976 ecb_i2a_digit (type,bits,digitmask, 1, 0); \
977 ecb_i2a_digit (type,bits,digitmask, 10, 1); \
978 ecb_i2a_digit (type,bits,digitmask, 100, 2); \
979 ecb_i2a_digit (type,bits,digitmask, 1000, 3); \
980 ecb_i2a_digit (type,bits,digitmask, 10000, 4); \
981 ecb_i2a_digit (type,bits,digitmask, 100000, 5); \
982 ecb_i2a_digit (type,bits,digitmask, 1000000, 6); \
983 ecb_i2a_digit (type,bits,digitmask, 10000000, 7); \
984 ecb_i2a_digit (type,bits,digitmask, 100000000, 8); \
985 ecb_i2a_digit (type,bits,digitmask, 1000000000, 9); \
986 return ptr; \
987}
988
989// predefined versions of the above, for various digits
990// ecb_i2a_xN = almost N digits, limit defined by macro
991// ecb_i2a_N = up to N digits, leading zeroes suppressed
992// ecb_i2a_0N = exactly N digits, including leading zeroes
993
994// non-leading-zero versions, limited range
995#define ECB_I2A_MAX_X5 59074 // limit for ecb_i2a_x5
996#define ECB_I2A_MAX_X10 2932500665 // limit for ecb_i2a_x10
997ecb_i2a_def ( x5, ptr, v, uint32_t, 26, 10000, 0)
998ecb_i2a_def (x10, ptr, v, uint64_t, 60, 1000000000, 0)
999
1000// non-leading zero versions, all digits, 4 and 9 are optimal for 32/64 bit
1001ecb_i2a_def ( 2, ptr, v, uint32_t, 10, 10, 0)
1002ecb_i2a_def ( 3, ptr, v, uint32_t, 12, 100, 0)
1003ecb_i2a_def ( 4, ptr, v, uint32_t, 26, 1000, 0)
1004ecb_i2a_def ( 5, ptr, v, uint64_t, 30, 10000, 0)
1005ecb_i2a_def ( 6, ptr, v, uint64_t, 36, 100000, 0)
1006ecb_i2a_def ( 7, ptr, v, uint64_t, 44, 1000000, 0)
1007ecb_i2a_def ( 8, ptr, v, uint64_t, 50, 10000000, 0)
1008ecb_i2a_def ( 9, ptr, v, uint64_t, 56, 100000000, 0)
1009
1010// leading-zero versions, all digits, 04 and 09 are optimal for 32/64 bit
1011ecb_i2a_def (02, ptr, v, uint32_t, 10, 10, 1)
1012ecb_i2a_def (03, ptr, v, uint32_t, 12, 100, 1)
1013ecb_i2a_def (04, ptr, v, uint32_t, 26, 1000, 1)
1014ecb_i2a_def (05, ptr, v, uint64_t, 30, 10000, 1)
1015ecb_i2a_def (06, ptr, v, uint64_t, 36, 100000, 1)
1016ecb_i2a_def (07, ptr, v, uint64_t, 44, 1000000, 1)
1017ecb_i2a_def (08, ptr, v, uint64_t, 50, 10000000, 1)
1018ecb_i2a_def (09, ptr, v, uint64_t, 56, 100000000, 1)
1019
1020#define ECB_I2A_I32_DIGITS 11
1021#define ECB_I2A_U32_DIGITS 10
1022#define ECB_I2A_I64_DIGITS 20
1023#define ECB_I2A_U32_DIGITS 21
1024#define ECB_I2A_DIGITS 21
1025
1026ecb_inline char *
1027ecb_i2a_u32 (char *ptr, uint32_t u)
1028{
1029 #if ECB_64BIT_NATIVE
1030 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1031 ptr = ecb_i2a_x10 (ptr, u);
1032 else // x10 almost, but not fully, covers 32 bit
1033 {
1034 uint32_t u1 = u % 1000000000;
1035 uint32_t u2 = u / 1000000000;
1036
1037 *ptr++ = u2 + '0';
1038 ptr = ecb_i2a_09 (ptr, u1);
1039 }
1040 #else
1041 if (ecb_expect_true (u <= ECB_I2A_MAX_X5))
1042 ecb_i2a_x5 (ptr, u);
1043 else if (ecb_expect_true (u <= ECB_I2A_MAX_X5 * 10000))
1044 {
1045 uint32_t u1 = u % 10000;
1046 uint32_t u2 = u / 10000;
1047
1048 ptr = ecb_i2a_x5 (ptr, u2);
1049 ptr = ecb_i2a_04 (ptr, u1);
1050 }
1051 else
1052 {
1053 uint32_t u1 = u % 10000;
1054 uint32_t ua = u / 10000;
1055 uint32_t u2 = ua % 10000;
1056 uint32_t u3 = ua / 10000;
1057
1058 ptr = ecb_i2a_2 (ptr, u3);
1059 ptr = ecb_i2a_04 (ptr, u2);
1060 ptr = ecb_i2a_04 (ptr, u1);
1061 }
1062 #endif
1063
1064 return ptr;
1065}
1066
1067ecb_inline char *
1068ecb_i2a_i32 (char *ptr, int32_t v)
1069{
1070 *ptr = '-'; ptr += v < 0;
1071 uint32_t u = v < 0 ? -(uint32_t)v : v;
1072
1073 #if ECB_64BIT_NATIVE
1074 ptr = ecb_i2a_x10 (ptr, u); // x10 fully covers 31 bit
1075 #else
1076 ptr = ecb_i2a_u32 (ptr, u);
1077 #endif
1078
1079 return ptr;
1080}
1081
1082ecb_inline char *
1083ecb_i2a_u64 (char *ptr, uint64_t u)
1084{
1085 #if ECB_64BIT_NATIVE
1086 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1087 ptr = ecb_i2a_x10 (ptr, u);
1088 else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000))
1089 {
1090 uint64_t u1 = u % 1000000000;
1091 uint64_t u2 = u / 1000000000;
1092
1093 ptr = ecb_i2a_x10 (ptr, u2);
1094 ptr = ecb_i2a_09 (ptr, u1);
1095 }
1096 else
1097 {
1098 uint64_t u1 = u % 1000000000;
1099 uint64_t ua = u / 1000000000;
1100 uint64_t u2 = ua % 1000000000;
1101 uint64_t u3 = ua / 1000000000;
1102
1103 ptr = ecb_i2a_2 (ptr, u3);
1104 ptr = ecb_i2a_09 (ptr, u2);
1105 ptr = ecb_i2a_09 (ptr, u1);
1106 }
1107 #else
1108 if (ecb_expect_true (u <= ECB_I2A_MAX_X5))
1109 ptr = ecb_i2a_x5 (ptr, u);
1110 else
1111 {
1112 uint64_t u1 = u % 10000;
1113 uint64_t u2 = u / 10000;
1114
1115 ptr = ecb_i2a_u64 (ptr, u2);
1116 ptr = ecb_i2a_04 (ptr, u1);
1117 }
1118 #endif
1119
1120 return ptr;
1121}
1122
1123ecb_inline char *
1124ecb_i2a_i64 (char *ptr, int64_t v)
1125{
1126 *ptr = '-'; ptr += v < 0;
1127 uint64_t u = v < 0 ? -(uint64_t)v : v;
1128
1129 #if ECB_64BIT_NATIVE
1130 if (ecb_expect_true (u <= ECB_I2A_MAX_X10))
1131 ptr = ecb_i2a_x10 (ptr, u);
1132 else if (ecb_expect_false (u <= ECB_I2A_MAX_X10 * 1000000000))
1133 {
1134 uint64_t u1 = u % 1000000000;
1135 uint64_t u2 = u / 1000000000;
1136
1137 ptr = ecb_i2a_x10 (ptr, u2);
1138 ptr = ecb_i2a_09 (ptr, u1);
1139 }
1140 else
1141 {
1142 uint64_t u1 = u % 1000000000;
1143 uint64_t ua = u / 1000000000;
1144 uint64_t u2 = ua % 1000000000;
1145 uint64_t u3 = ua / 1000000000;
1146
1147 // 2**31 is 19 digits, so the top is exactly one digit
1148 *ptr++ = u3 + '0';
1149 ptr = ecb_i2a_09 (ptr, u2);
1150 ptr = ecb_i2a_09 (ptr, u1);
1151 }
1152 #else
1153 ptr = ecb_i2a_u64 (ptr, u);
1154 #endif
1155
1156 return ptr;
934} 1157}
935 1158
936/*******************************************************************************/ 1159/*******************************************************************************/
937/* floating point stuff, can be disabled by defining ECB_NO_LIBM */ 1160/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
938 1161

Diff Legend

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