decompress_common: switch to subtables for Huffman decoding
[wimlib] / include / wimlib / compiler.h
1 /*
2  * compiler.h
3  *
4  * Compiler-specific definitions.  Currently, only GCC and clang are supported.
5  *
6  * The following copying information applies to this specific source code file:
7  *
8  * Written in 2013-2016 by Eric Biggers <ebiggers3@gmail.com>
9  *
10  * To the extent possible under law, the author(s) have dedicated all copyright
11  * and related and neighboring rights to this software to the public domain
12  * worldwide via the Creative Commons Zero 1.0 Universal Public Domain
13  * Dedication (the "CC0").
14  *
15  * This software is distributed in the hope that it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17  * FOR A PARTICULAR PURPOSE. See the CC0 for more details.
18  *
19  * You should have received a copy of the CC0 along with this software; if not
20  * see <http://creativecommons.org/publicdomain/zero/1.0/>.
21  */
22
23 #ifndef _WIMLIB_COMPILER_H
24 #define _WIMLIB_COMPILER_H
25
26 /* Is the compiler GCC of the specified version or later?  This always returns
27  * false for clang, since clang is "frozen" at GNUC 4.2.  The __has_*
28  * feature-test macros should be used to detect clang functionality instead.  */
29 #define GCC_PREREQ(major, minor)                                        \
30         (!defined(__clang__) && !defined(__INTEL_COMPILER) &&           \
31          (__GNUC__ > major ||                                           \
32           (__GNUC__ == major && __GNUC_MINOR__ >= minor)))
33
34 /* Feature-test macros defined by recent versions of clang.  */
35 #ifndef __has_attribute
36 #  define __has_attribute(attribute)    0
37 #endif
38 #ifndef __has_feature
39 #  define __has_feature(feature)        0
40 #endif
41 #ifndef __has_builtin
42 #  define __has_builtin(builtin)        0
43 #endif
44
45 /* Declare that the annotated function should be exported from the shared
46  * library (or DLL).  */
47 #ifdef __WIN32__
48 #  define WIMLIBAPI __declspec(dllexport)
49 #else
50 #  define WIMLIBAPI __attribute__((visibility("default")))
51 #endif
52
53 /* Declare that the annotated function should be inlined.  Currently, we force
54  * the compiler to honor this because we use 'inline' in highly tuned code, e.g.
55  * compression codecs.  */
56 #define inline                  inline __attribute__((always_inline))
57
58 /* Declare that the annotated function should *not* be inlined.  */
59 #define noinline                __attribute__((noinline))
60
61 /* Functionally the same as 'noinline', but documents that the reason for not
62  * inlining is to prevent the annotated function from being inlined into a
63  * recursive function, thereby increasing its stack usage.  */
64 #define noinline_for_stack      noinline
65
66 /* Hint that the expression is usually true.  */
67 #define likely(expr)            __builtin_expect(!!(expr), 1)
68
69 /* Hint that the expression is usually false.  */
70 #define unlikely(expr)          __builtin_expect(!!(expr), 0)
71
72 /* Prefetch into L1 cache for read.  */
73 #define prefetchr(addr)         __builtin_prefetch((addr), 0)
74
75 /* Prefetch into L1 cache for write.  */
76 #define prefetchw(addr)         __builtin_prefetch((addr), 1)
77
78 /* Declare that the members of the annotated struct are tightly packed, and the
79  * struct itself may be misaligned.  */
80 #define _packed_attribute       __attribute__((packed))
81
82 /* Declare that the annotated variable, or variables of the annotated type, are
83  * to be aligned on n-byte boundaries.  */
84 #define _aligned_attribute(n)   __attribute__((aligned(n)))
85
86 /* Declare that pointers to the annotated type may alias other pointers.  */
87 #define _may_alias_attribute    __attribute__((may_alias))
88
89 /* Hint that the annotated function is rarely called.  */
90 #if GCC_PREREQ(4, 4) || __has_attribute(cold)
91 #  define _cold_attribute       __attribute__((cold))
92 #else
93 #  define _cold_attribute
94 #endif
95
96 /* Hint that the annotated function is malloc-like: any non-null pointer it
97  * returns will not alias any pointer previously in use by the program.  */
98 #define _malloc_attribute       __attribute__((malloc))
99
100 /* Hint that the annotated function takes a printf()-like format string and
101  * arguments.  This is currently disabled on Windows because MinGW does not
102  * support this attribute on functions taking wide-character strings.  */
103 #ifdef __WIN32__
104 #  define _format_attribute(type, format_str, format_start)
105 #else
106 #  define _format_attribute(type, format_str, format_start)     \
107                         __attribute__((format(type, format_str, format_start)))
108 #endif
109
110 /* Hint that the annotated function is intentionally not used.  This might be
111  * the case if the function contains only static assertions.  */
112 #define _unused_attribute       __attribute__((unused))
113
114 /* Endianness definitions.  Either CPU_IS_BIG_ENDIAN or CPU_IS_LITTLE_ENDIAN is
115  * set to 1.  The other is set to 0.  Note that newer gcc supports
116  * __BYTE_ORDER__ for easily determining the endianness; older gcc doesn't.  In
117  * the latter case we fall back to a configure-time check.  */
118 #ifdef __BYTE_ORDER__
119 #  define CPU_IS_BIG_ENDIAN     (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
120 #elif defined(HAVE_CONFIG_H)
121 #  include "config.h"
122 #  ifdef WORDS_BIGENDIAN
123 #    define CPU_IS_BIG_ENDIAN 1
124 #  else
125 #    define CPU_IS_BIG_ENDIAN 0
126 #  endif
127 #endif
128 #define CPU_IS_LITTLE_ENDIAN (!CPU_IS_BIG_ENDIAN)
129
130 /* UNALIGNED_ACCESS_IS_FAST should be defined to 1 if unaligned memory accesses
131  * can be performed efficiently on the target platform.  */
132 #if defined(__x86_64__) || defined(__i386__) || defined(__ARM_FEATURE_UNALIGNED)
133 #  define UNALIGNED_ACCESS_IS_FAST 1
134 #else
135 #  define UNALIGNED_ACCESS_IS_FAST 0
136 #endif
137
138 /* Get the type of the specified expression.  */
139 #define typeof     __typeof__
140
141 /* Get the minimum of two variables, without multiple evaluation.  */
142 #ifndef min
143 #  define min(a, b)  ({ typeof(a) _a = (a); typeof(b) _b = (b); \
144                         (_a < _b) ? _a : _b; })
145 #endif
146
147 /* Get the maximum of two variables, without multiple evaluation.  */
148 #ifndef max
149 #  define max(a, b)  ({ typeof(a) _a = (a); typeof(b) _b = (b); \
150                         (_a > _b) ? _a : _b; })
151 #endif
152
153 /* Swap the values of two variables, without multiple evaluation.  */
154 #ifndef swap
155 #  define swap(a, b) ({ typeof(a) _a = (a); (a) = (b); (b) = _a; })
156 #endif
157
158 /* (Optional) Efficiently swap the bytes of a 16-bit integer.  */
159 #if GCC_PREREQ(4, 8) || __has_builtin(__builtin_bswap16)
160 #  define compiler_bswap16 __builtin_bswap16
161 #endif
162
163 /* (Optional) Efficiently swap the bytes of a 32-bit integer.  */
164 #if GCC_PREREQ(4, 3) || __has_builtin(__builtin_bswap32)
165 #  define compiler_bswap32 __builtin_bswap32
166 #endif
167
168 /* (Optional) Efficiently swap the bytes of a 64-bit integer.  */
169 #if GCC_PREREQ(4, 3) || __has_builtin(__builtin_bswap64)
170 #  define compiler_bswap64 __builtin_bswap64
171 #endif
172
173 /* (Optional) Find Last Set bit and Find First Set bit macros.  */
174 #define compiler_fls32(n)       (31 - __builtin_clz(n))
175 #define compiler_fls64(n)       (63 - __builtin_clzll(n))
176 #define compiler_ffs32(n)       __builtin_ctz(n)
177 #define compiler_ffs64(n)       __builtin_ctzll(n)
178
179 /* Optional definitions for checking with 'sparse'.  */
180 #ifdef __CHECKER__
181 #  define _bitwise_attr __attribute__((bitwise))
182 #  define _force_attr   __attribute__((force))
183 #else
184 #  define _bitwise_attr
185 #  define _force_attr
186 #endif
187
188 /* STATIC_ASSERT() - verify the truth of an expression at compilation time.  */
189 #if __STDC_VERSION__ >= 201112L
190 #  define STATIC_ASSERT(expr)   _Static_assert((expr), "")
191 #else
192 #  define STATIC_ASSERT(expr)   ((void)sizeof(char[1 - 2 * !(expr)]))
193 #endif
194
195 /* STATIC_ASSERT_ZERO() - verify the truth of an expression at compilation time
196  * and also produce a result of value '0' to be used in constant expressions */
197 #define STATIC_ASSERT_ZERO(expr) ((int)sizeof(char[-!(expr)]))
198
199 #define CONCAT_IMPL(s1, s2)     s1##s2
200
201 /* CONCAT() - concatenate two tokens at preprocessing time.  */
202 #define CONCAT(s1, s2)          CONCAT_IMPL(s1, s2)
203
204 #endif /* _WIMLIB_COMPILER_H */