1 /* Copyright 2016 Google Inc. All Rights Reserved.
2
3 Distributed under MIT license.
4 See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
5 */
6
7 /* Macros for compiler / platform specific features and build options.
8
9 Build options are:
10 * BROTLI_BUILD_32_BIT disables 64-bit optimizations
11 * BROTLI_BUILD_64_BIT forces to use 64-bit optimizations
12 * BROTLI_BUILD_BIG_ENDIAN forces to use big-endian optimizations
13 * BROTLI_BUILD_ENDIAN_NEUTRAL disables endian-aware optimizations
14 * BROTLI_BUILD_LITTLE_ENDIAN forces to use little-endian optimizations
15 * BROTLI_BUILD_PORTABLE disables dangerous optimizations, like unaligned
16 read and overlapping memcpy; this reduces decompression speed by 5%
17 * BROTLI_BUILD_NO_RBIT disables "rbit" optimization for ARM CPUs
18 * BROTLI_DEBUG dumps file name and line number when decoder detects stream
19 or memory error
20 * BROTLI_ENABLE_LOG enables asserts and dumps various state information
21 */
22
23 #ifndef BROTLI_COMMON_PLATFORM_H_
24 #define BROTLI_COMMON_PLATFORM_H_
25
26 //#include <string.h> /* memcpy */
27 //#include <stdlib.h> /* malloc, free */
28
29 #include <brotli/port.h>
30 #include <brotli/types.h>
31 #include <BrotliDecompressLibInternal.h>
32
33 #if defined(OS_LINUX) || defined(OS_CYGWIN)
34 #include <endian.h>
35 #elif defined(OS_FREEBSD)
36 #include <machine/endian.h>
37 #elif defined(OS_MACOSX)
38 #include <machine/endian.h>
39 /* Let's try and follow the Linux convention */
40 #define BROTLI_X_BYTE_ORDER BYTE_ORDER
41 #define BROTLI_X_LITTLE_ENDIAN LITTLE_ENDIAN
42 #define BROTLI_X_BIG_ENDIAN BIG_ENDIAN
43 #endif
44
45 #if defined(BROTLI_ENABLE_LOG) || defined(BROTLI_DEBUG)
46 #include <assert.h>
47 #include <stdio.h>
48 #endif
49
50 /* The following macros were borrowed from https://github.com/nemequ/hedley
51 * with permission of original author - Evan Nemerson <evan@nemerson.com> */
52
53 /* >>> >>> >>> hedley macros */
54
55 /* Define "BROTLI_PREDICT_TRUE" and "BROTLI_PREDICT_FALSE" macros for capable
56 compilers.
57
58 To apply compiler hint, enclose the branching condition into macros, like this:
59
60 if (BROTLI_PREDICT_TRUE(zero == 0)) {
61 // main execution path
62 } else {
63 // compiler should place this code outside of main execution path
64 }
65
66 OR:
67
68 if (BROTLI_PREDICT_FALSE(something_rare_or_unexpected_happens)) {
69 // compiler should place this code outside of main execution path
70 }
71
72 */
73 #if BROTLI_GNUC_HAS_BUILTIN(__builtin_expect, 3, 0, 0) || \
74 BROTLI_INTEL_VERSION_CHECK(16, 0, 0) || \
75 BROTLI_SUNPRO_VERSION_CHECK(5, 12, 0) || \
76 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || \
77 BROTLI_IBM_VERSION_CHECK(10, 1, 0) || \
78 BROTLI_TI_VERSION_CHECK(7, 3, 0) || \
79 BROTLI_TINYC_VERSION_CHECK(0, 9, 27)
80 #define BROTLI_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
81 #define BROTLI_PREDICT_FALSE(x) (__builtin_expect(x, 0))
82 #else
83 #define BROTLI_PREDICT_FALSE(x) (x)
84 #define BROTLI_PREDICT_TRUE(x) (x)
85 #endif
86
87 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
88 !defined(__cplusplus)
89 #define BROTLI_RESTRICT restrict
90 #elif BROTLI_GNUC_VERSION_CHECK(3, 1, 0) || \
91 BROTLI_MSVC_VERSION_CHECK(14, 0, 0) || \
92 BROTLI_INTEL_VERSION_CHECK(16, 0, 0) || \
93 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || \
94 BROTLI_IBM_VERSION_CHECK(10, 1, 0) || \
95 BROTLI_PGI_VERSION_CHECK(17, 10, 0) || \
96 BROTLI_TI_VERSION_CHECK(8, 0, 0) || \
97 BROTLI_IAR_VERSION_CHECK(8, 0, 0) || \
98 (BROTLI_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus))
99 #define BROTLI_RESTRICT __restrict
100 #elif BROTLI_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
101 #define BROTLI_RESTRICT _Restrict
102 #else
103 #define BROTLI_RESTRICT
104 #endif
105
106 #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
107 (defined(__cplusplus) && (__cplusplus >= 199711L))
108 #define BROTLI_MAYBE_INLINE inline
109 #elif defined(__GNUC_STDC_INLINE__) || defined(__GNUC_GNU_INLINE__) || \
110 BROTLI_ARM_VERSION_CHECK(6, 2, 0)
111 #define BROTLI_MAYBE_INLINE __inline__
112 #elif BROTLI_MSVC_VERSION_CHECK(12, 0, 0) || \
113 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || BROTLI_TI_VERSION_CHECK(8, 0, 0)
114 #define BROTLI_MAYBE_INLINE __inline
115 #else
116 #define BROTLI_MAYBE_INLINE
117 #endif
118
119 #if BROTLI_GNUC_HAS_ATTRIBUTE(always_inline, 4, 0, 0) || \
120 BROTLI_INTEL_VERSION_CHECK(16, 0, 0) || \
121 BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) || \
122 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || \
123 BROTLI_IBM_VERSION_CHECK(10, 1, 0) || \
124 BROTLI_TI_VERSION_CHECK(8, 0, 0) || \
125 (BROTLI_TI_VERSION_CHECK(7, 3, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
126 #define BROTLI_INLINE BROTLI_MAYBE_INLINE __attribute__((__always_inline__))
127 #elif BROTLI_MSVC_VERSION_CHECK(12, 0, 0)
128 #define BROTLI_INLINE BROTLI_MAYBE_INLINE __forceinline
129 #elif BROTLI_TI_VERSION_CHECK(7, 0, 0) && defined(__cplusplus)
130 #define BROTLI_INLINE BROTLI_MAYBE_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
131 #elif BROTLI_IAR_VERSION_CHECK(8, 0, 0)
132 #define BROTLI_INLINE BROTLI_MAYBE_INLINE _Pragma("inline=forced")
133 #else
134 #define BROTLI_INLINE BROTLI_MAYBE_INLINE
135 #endif
136
137 #if BROTLI_GNUC_HAS_ATTRIBUTE(noinline, 4, 0, 0) || \
138 BROTLI_INTEL_VERSION_CHECK(16, 0, 0) || \
139 BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) || \
140 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || \
141 BROTLI_IBM_VERSION_CHECK(10, 1, 0) || \
142 BROTLI_TI_VERSION_CHECK(8, 0, 0) || \
143 (BROTLI_TI_VERSION_CHECK(7, 3, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
144 #define BROTLI_NOINLINE __attribute__((__noinline__))
145 #elif BROTLI_MSVC_VERSION_CHECK(13, 10, 0)
146 #define BROTLI_NOINLINE __declspec(noinline)
147 #elif BROTLI_PGI_VERSION_CHECK(10, 2, 0)
148 #define BROTLI_NOINLINE _Pragma("noinline")
149 #elif BROTLI_TI_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
150 #define BROTLI_NOINLINE _Pragma("FUNC_CANNOT_INLINE;")
151 #elif BROTLI_IAR_VERSION_CHECK(8, 0, 0)
152 #define BROTLI_NOINLINE _Pragma("inline=never")
153 #else
154 #define BROTLI_NOINLINE
155 #endif
156
157 /* BROTLI_INTERNAL could be defined to override visibility, e.g. for tests. */
158 #if !defined(BROTLI_INTERNAL)
159 #if defined(_WIN32) || defined(__CYGWIN__)
160 #define BROTLI_INTERNAL
161 #elif BROTLI_GNUC_VERSION_CHECK(3, 3, 0) || \
162 BROTLI_TI_VERSION_CHECK(8, 0, 0) || \
163 BROTLI_INTEL_VERSION_CHECK(16, 0, 0) || \
164 BROTLI_ARM_VERSION_CHECK(4, 1, 0) || \
165 BROTLI_IBM_VERSION_CHECK(13, 1, 0) || \
166 BROTLI_SUNPRO_VERSION_CHECK(5, 11, 0) || \
167 (BROTLI_TI_VERSION_CHECK(7, 3, 0) && \
168 defined(__TI_GNU_ATTRIBUTE_SUPPORT__) && defined(__TI_EABI__))
169 #define BROTLI_INTERNAL __attribute__ ((visibility ("hidden")))
170 #else
171 #define BROTLI_INTERNAL
172 #endif
173 #endif
174
175 /* <<< <<< <<< end of hedley macros. */
176
177 #if BROTLI_GNUC_HAS_ATTRIBUTE(unused, 2, 7, 0) || \
178 BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
179 #define BROTLI_UNUSED_FUNCTION static BROTLI_INLINE __attribute__ ((unused))
180 #else
181 #define BROTLI_UNUSED_FUNCTION static BROTLI_INLINE
182 #endif
183
184 #if (defined(__ARM_ARCH) && (__ARM_ARCH == 7)) || \
185 (defined(M_ARM) && (M_ARM == 7))
186 #define BROTLI_TARGET_ARMV7
187 #endif /* ARMv7 */
188
189 #if (defined(__ARM_ARCH) && (__ARM_ARCH == 8)) || \
190 defined(__aarch64__) || defined(__ARM64_ARCH_8__)
191 #define BROTLI_TARGET_ARMV8_ANY
192
193 #if defined(__ARM_32BIT_STATE)
194 #define BROTLI_TARGET_ARMV8_32
195 #elif defined(__ARM_64BIT_STATE)
196 #define BROTLI_TARGET_ARMV8_64
197 #endif
198
199 #endif /* ARMv8 */
200
201 #if defined(__i386) || defined(_M_IX86)
202 #define BROTLI_TARGET_X86
203 #endif
204
205 #if defined(__x86_64__) || defined(_M_X64)
206 #define BROTLI_TARGET_X64
207 #endif
208
209 #if defined(__PPC64__)
210 #define BROTLI_TARGET_POWERPC64
211 #endif
212
213 #if defined(__riscv) && defined(__riscv_xlen) && __riscv_xlen == 64
214 #define BROTLI_TARGET_RISCV64
215 #endif
216
217 #if defined(BROTLI_BUILD_64_BIT)
218 #define BROTLI_64_BITS 1
219 #elif defined(BROTLI_BUILD_32_BIT)
220 #define BROTLI_64_BITS 0
221 #elif defined(BROTLI_TARGET_X64) || defined(BROTLI_TARGET_ARMV8_64) || \
222 defined(BROTLI_TARGET_POWERPC64) || defined(BROTLI_TARGET_RISCV64)
223 #define BROTLI_64_BITS 1
224 #else
225 #define BROTLI_64_BITS 0
226 #endif
227
228 #if (BROTLI_64_BITS)
229 #define brotli_reg_t uint64_t
230 #else
231 #define brotli_reg_t uint32_t
232 #endif
233
234 #if defined(BROTLI_BUILD_BIG_ENDIAN)
235 #define BROTLI_BIG_ENDIAN 1
236 #elif defined(BROTLI_BUILD_LITTLE_ENDIAN)
237 #define BROTLI_LITTLE_ENDIAN 1
238 #elif defined(BROTLI_BUILD_ENDIAN_NEUTRAL)
239 /* Just break elif chain. */
240 #elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
241 #define BROTLI_LITTLE_ENDIAN 1
242 #elif defined(_WIN32) || defined(BROTLI_TARGET_X64)
243 /* Win32 & x64 can currently always be assumed to be little endian */
244 #define BROTLI_LITTLE_ENDIAN 1
245 #elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
246 #define BROTLI_BIG_ENDIAN 1
247 #elif defined(BROTLI_X_BYTE_ORDER)
248 #if BROTLI_X_BYTE_ORDER == BROTLI_X_LITTLE_ENDIAN
249 #define BROTLI_LITTLE_ENDIAN 1
250 #elif BROTLI_X_BYTE_ORDER == BROTLI_X_BIG_ENDIAN
251 #define BROTLI_BIG_ENDIAN 1
252 #endif
253 #endif /* BROTLI_X_BYTE_ORDER */
254
255 #if !defined(BROTLI_LITTLE_ENDIAN)
256 #define BROTLI_LITTLE_ENDIAN 0
257 #endif
258
259 #if !defined(BROTLI_BIG_ENDIAN)
260 #define BROTLI_BIG_ENDIAN 0
261 #endif
262
263 #if defined(BROTLI_X_BYTE_ORDER)
264 #undef BROTLI_X_BYTE_ORDER
265 #undef BROTLI_X_LITTLE_ENDIAN
266 #undef BROTLI_X_BIG_ENDIAN
267 #endif
268
269 #if defined(BROTLI_BUILD_PORTABLE)
270 #define BROTLI_ALIGNED_READ (!!1)
271 #elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) || \
272 defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY) || \
273 defined(BROTLI_TARGET_RISCV64)
274 /* Allow unaligned read only for white-listed CPUs. */
275 #define BROTLI_ALIGNED_READ (!!0)
276 #else
277 #define BROTLI_ALIGNED_READ (!!1)
278 #endif
279
280 #if BROTLI_ALIGNED_READ
281 /* Portable unaligned memory access: read / write values via memcpy. */
BrotliUnalignedRead16(const void * p)282 static BROTLI_INLINE uint16_t BrotliUnalignedRead16(const void* p) {
283 uint16_t t;
284 memcpy(&t, p, sizeof t);
285 return t;
286 }
BrotliUnalignedRead32(const void * p)287 static BROTLI_INLINE uint32_t BrotliUnalignedRead32(const void* p) {
288 uint32_t t;
289 memcpy(&t, p, sizeof t);
290 return t;
291 }
BrotliUnalignedRead64(const void * p)292 static BROTLI_INLINE uint64_t BrotliUnalignedRead64(const void* p) {
293 uint64_t t;
294 memcpy(&t, p, sizeof t);
295 return t;
296 }
BrotliUnalignedWrite64(void * p,uint64_t v)297 static BROTLI_INLINE void BrotliUnalignedWrite64(void* p, uint64_t v) {
298 memcpy(p, &v, sizeof v);
299 }
300 #else /* BROTLI_ALIGNED_READ */
301 /* Unaligned memory access is allowed: just cast pointer to requested type. */
302 #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) || \
303 defined(MEMORY_SANITIZER)
304 /* Consider we have an unaligned load/store of 4 bytes from address 0x...05.
305 AddressSanitizer will treat it as a 3-byte access to the range 05:07 and
306 will miss a bug if 08 is the first unaddressable byte.
307 ThreadSanitizer will also treat this as a 3-byte access to 05:07 and will
308 miss a race between this access and some other accesses to 08.
309 MemorySanitizer will correctly propagate the shadow on unaligned stores
310 and correctly report bugs on unaligned loads, but it may not properly
311 update and report the origin of the uninitialized memory.
312 For all three tools, replacing an unaligned access with a tool-specific
313 callback solves the problem. */
314 #if defined(__cplusplus)
315 extern "C" {
316 #endif /* __cplusplus */
317 uint16_t __sanitizer_unaligned_load16(const void* p);
318 uint32_t __sanitizer_unaligned_load32(const void* p);
319 uint64_t __sanitizer_unaligned_load64(const void* p);
320 void __sanitizer_unaligned_store64(void* p, uint64_t v);
321 #if defined(__cplusplus)
322 } /* extern "C" */
323 #endif /* __cplusplus */
324 #define BrotliUnalignedRead16 __sanitizer_unaligned_load16
325 #define BrotliUnalignedRead32 __sanitizer_unaligned_load32
326 #define BrotliUnalignedRead64 __sanitizer_unaligned_load64
327 #define BrotliUnalignedWrite64 __sanitizer_unaligned_store64
328 #else
BrotliUnalignedRead16(const void * p)329 static BROTLI_INLINE uint16_t BrotliUnalignedRead16(const void* p) {
330 return *(const uint16_t*)p;
331 }
BrotliUnalignedRead32(const void * p)332 static BROTLI_INLINE uint32_t BrotliUnalignedRead32(const void* p) {
333 return *(const uint32_t*)p;
334 }
335 #if (BROTLI_64_BITS)
BrotliUnalignedRead64(const void * p)336 static BROTLI_INLINE uint64_t BrotliUnalignedRead64(const void* p) {
337 return *(const uint64_t*)p;
338 }
BrotliUnalignedWrite64(void * p,uint64_t v)339 static BROTLI_INLINE void BrotliUnalignedWrite64(void* p, uint64_t v) {
340 *(uint64_t*)p = v;
341 }
342 #else /* BROTLI_64_BITS */
343 /* Avoid emitting LDRD / STRD, which require properly aligned address. */
344 /* If __attribute__(aligned) is available, use that. Otherwise, memcpy. */
345
346 #if BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0)
347 typedef __attribute__((aligned(1))) uint64_t brotli_unaligned_uint64_t;
348
BrotliUnalignedRead64(const void * p)349 static BROTLI_INLINE uint64_t BrotliUnalignedRead64(const void* p) {
350 return (uint64_t) ((brotli_unaligned_uint64_t*) p)[0];
351 }
BrotliUnalignedWrite64(void * p,uint64_t v)352 static BROTLI_INLINE void BrotliUnalignedWrite64(void* p, uint64_t v) {
353 brotli_unaligned_uint64_t* dwords = (brotli_unaligned_uint64_t*) p;
354 dwords[0] = (brotli_unaligned_uint64_t) v;
355 }
356 #else /* BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0) */
BrotliUnalignedRead64(const void * p)357 static BROTLI_INLINE uint64_t BrotliUnalignedRead64(const void* p) {
358 uint64_t v;
359 memcpy(&v, p, sizeof(uint64_t));
360 return v;
361 }
362
BrotliUnalignedWrite64(void * p,uint64_t v)363 static BROTLI_INLINE void BrotliUnalignedWrite64(void* p, uint64_t v) {
364 memcpy(p, &v, sizeof(uint64_t));
365 }
366 #endif /* BROTLI_GNUC_HAS_ATTRIBUTE(aligned, 2, 7, 0) */
367 #endif /* BROTLI_64_BITS */
368 #endif /* ASAN / TSAN / MSAN */
369 #endif /* BROTLI_ALIGNED_READ */
370
371 #if BROTLI_LITTLE_ENDIAN
372 /* Straight endianness. Just read / write values. */
373 #define BROTLI_UNALIGNED_LOAD16LE BrotliUnalignedRead16
374 #define BROTLI_UNALIGNED_LOAD32LE BrotliUnalignedRead32
375 #define BROTLI_UNALIGNED_LOAD64LE BrotliUnalignedRead64
376 #define BROTLI_UNALIGNED_STORE64LE BrotliUnalignedWrite64
377 #elif BROTLI_BIG_ENDIAN /* BROTLI_LITTLE_ENDIAN */
378 /* Explain compiler to byte-swap values. */
379 #define BROTLI_BSWAP16_(V) ((uint16_t)( \
380 (((V) & 0xFFU) << 8) | \
381 (((V) >> 8) & 0xFFU)))
BROTLI_UNALIGNED_LOAD16LE(const void * p)382 static BROTLI_INLINE uint16_t BROTLI_UNALIGNED_LOAD16LE(const void* p) {
383 uint16_t value = BrotliUnalignedRead16(p);
384 return BROTLI_BSWAP16_(value);
385 }
386 #define BROTLI_BSWAP32_(V) ( \
387 (((V) & 0xFFU) << 24) | (((V) & 0xFF00U) << 8) | \
388 (((V) >> 8) & 0xFF00U) | (((V) >> 24) & 0xFFU))
BROTLI_UNALIGNED_LOAD32LE(const void * p)389 static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32LE(const void* p) {
390 uint32_t value = BrotliUnalignedRead32(p);
391 return BROTLI_BSWAP32_(value);
392 }
393 #define BROTLI_BSWAP64_(V) ( \
394 (((V) & 0xFFU) << 56) | (((V) & 0xFF00U) << 40) | \
395 (((V) & 0xFF0000U) << 24) | (((V) & 0xFF000000U) << 8) | \
396 (((V) >> 8) & 0xFF000000U) | (((V) >> 24) & 0xFF0000U) | \
397 (((V) >> 40) & 0xFF00U) | (((V) >> 56) & 0xFFU))
BROTLI_UNALIGNED_LOAD64LE(const void * p)398 static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void* p) {
399 uint64_t value = BrotliUnalignedRead64(p);
400 return BROTLI_BSWAP64_(value);
401 }
BROTLI_UNALIGNED_STORE64LE(void * p,uint64_t v)402 static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void* p, uint64_t v) {
403 uint64_t value = BROTLI_BSWAP64_(v);
404 BrotliUnalignedWrite64(p, value);
405 }
406 #else /* BROTLI_LITTLE_ENDIAN */
407 /* Read / store values byte-wise; hopefully compiler will understand. */
BROTLI_UNALIGNED_LOAD16LE(const void * p)408 static BROTLI_INLINE uint16_t BROTLI_UNALIGNED_LOAD16LE(const void* p) {
409 const uint8_t* in = (const uint8_t*)p;
410 return (uint16_t)(in[0] | (in[1] << 8));
411 }
BROTLI_UNALIGNED_LOAD32LE(const void * p)412 static BROTLI_INLINE uint32_t BROTLI_UNALIGNED_LOAD32LE(const void* p) {
413 const uint8_t* in = (const uint8_t*)p;
414 uint32_t value = (uint32_t)(in[0]);
415 value |= (uint32_t)(in[1]) << 8;
416 value |= (uint32_t)(in[2]) << 16;
417 value |= (uint32_t)(in[3]) << 24;
418 return value;
419 }
BROTLI_UNALIGNED_LOAD64LE(const void * p)420 static BROTLI_INLINE uint64_t BROTLI_UNALIGNED_LOAD64LE(const void* p) {
421 const uint8_t* in = (const uint8_t*)p;
422 uint64_t value = (uint64_t)(in[0]);
423 value |= (uint64_t)(in[1]) << 8;
424 value |= (uint64_t)(in[2]) << 16;
425 value |= (uint64_t)(in[3]) << 24;
426 value |= (uint64_t)(in[4]) << 32;
427 value |= (uint64_t)(in[5]) << 40;
428 value |= (uint64_t)(in[6]) << 48;
429 value |= (uint64_t)(in[7]) << 56;
430 return value;
431 }
BROTLI_UNALIGNED_STORE64LE(void * p,uint64_t v)432 static BROTLI_INLINE void BROTLI_UNALIGNED_STORE64LE(void* p, uint64_t v) {
433 uint8_t* out = (uint8_t*)p;
434 out[0] = (uint8_t)v;
435 out[1] = (uint8_t)(v >> 8);
436 out[2] = (uint8_t)(v >> 16);
437 out[3] = (uint8_t)(v >> 24);
438 out[4] = (uint8_t)(v >> 32);
439 out[5] = (uint8_t)(v >> 40);
440 out[6] = (uint8_t)(v >> 48);
441 out[7] = (uint8_t)(v >> 56);
442 }
443 #endif /* BROTLI_LITTLE_ENDIAN */
444
445 /* BROTLI_IS_CONSTANT macros returns true for compile-time constants. */
446 #if BROTLI_GNUC_HAS_BUILTIN(__builtin_constant_p, 3, 0, 1) || \
447 BROTLI_INTEL_VERSION_CHECK(16, 0, 0)
448 #define BROTLI_IS_CONSTANT(x) (!!__builtin_constant_p(x))
449 #else
450 #define BROTLI_IS_CONSTANT(x) (!!0)
451 #endif
452
453 #if defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY)
454 #define BROTLI_HAS_UBFX (!!1)
455 #else
456 #define BROTLI_HAS_UBFX (!!0)
457 #endif
458
459 #if defined(BROTLI_ENABLE_LOG)
460 #define BROTLI_DCHECK(x) assert(x)
461 #define BROTLI_LOG(x) printf x
462 #else
463 #define BROTLI_DCHECK(x)
464 #define BROTLI_LOG(x)
465 #endif
466
467 #if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
BrotliDump(const char * f,int l,const char * fn)468 static BROTLI_INLINE void BrotliDump(const char* f, int l, const char* fn) {
469 fprintf(stderr, "%s:%d (%s)\n", f, l, fn);
470 fflush(stderr);
471 }
472 #define BROTLI_DUMP() BrotliDump(__FILE__, __LINE__, __FUNCTION__)
473 #else
474 #define BROTLI_DUMP() (void)(0)
475 #endif
476
477 /* TODO: add appropriate icc/sunpro/arm/ibm/ti checks. */
478 #if (BROTLI_GNUC_VERSION_CHECK(3, 0, 0) || defined(__llvm__)) && \
479 !defined(BROTLI_BUILD_NO_RBIT)
480 #if defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY)
481 /* TODO: detect ARMv6T2 and enable this code for it. */
BrotliRBit(brotli_reg_t input)482 static BROTLI_INLINE brotli_reg_t BrotliRBit(brotli_reg_t input) {
483 brotli_reg_t output;
484 __asm__("rbit %0, %1\n" : "=r"(output) : "r"(input));
485 return output;
486 }
487 #define BROTLI_RBIT(x) BrotliRBit(x)
488 #endif /* armv7 / armv8 */
489 #endif /* gcc || clang */
490 #if !defined(BROTLI_RBIT)
BrotliRBit(void)491 static BROTLI_INLINE void BrotliRBit(void) { /* Should break build if used. */ }
492 #endif /* BROTLI_RBIT */
493
494 #define BROTLI_REPEAT(N, X) { \
495 if ((N & 1) != 0) {X;} \
496 if ((N & 2) != 0) {X; X;} \
497 if ((N & 4) != 0) {X; X; X; X;} \
498 }
499
500 #define BROTLI_UNUSED(X) (void)(X)
501
502 #define BROTLI_MIN_MAX(T) \
503 static BROTLI_INLINE T brotli_min_ ## T (T a, T b) { return a < b ? a : b; } \
504 static BROTLI_INLINE T brotli_max_ ## T (T a, T b) { return a > b ? a : b; }
BROTLI_MIN_MAX(float)505 BROTLI_MIN_MAX(double) BROTLI_MIN_MAX(float) BROTLI_MIN_MAX(int)
506 BROTLI_MIN_MAX(size_t) BROTLI_MIN_MAX(uint32_t) BROTLI_MIN_MAX(uint8_t)
507 #undef BROTLI_MIN_MAX
508 #define BROTLI_MIN(T, A, B) (brotli_min_ ## T((A), (B)))
509 #define BROTLI_MAX(T, A, B) (brotli_max_ ## T((A), (B)))
510
511 #define BROTLI_SWAP(T, A, I, J) { \
512 T __brotli_swap_tmp = (A)[(I)]; \
513 (A)[(I)] = (A)[(J)]; \
514 (A)[(J)] = __brotli_swap_tmp; \
515 }
516
517 /* Default brotli_alloc_func */
518 static void* BrotliDefaultAllocFunc(void* opaque, size_t size) {
519 BROTLI_UNUSED(opaque);
520 return BrDummyMalloc(size);
521 }
522
523 /* Default brotli_free_func */
BrotliDefaultFreeFunc(void * opaque,void * address)524 static void BrotliDefaultFreeFunc(void* opaque, void* address) {
525 BROTLI_UNUSED(opaque);
526 BrDummyFree(address);
527 }
528
BrotliSuppressUnusedFunctions(void)529 BROTLI_UNUSED_FUNCTION void BrotliSuppressUnusedFunctions(void) {
530 BROTLI_UNUSED(&BrotliSuppressUnusedFunctions);
531 BROTLI_UNUSED(&BrotliUnalignedRead16);
532 BROTLI_UNUSED(&BrotliUnalignedRead32);
533 BROTLI_UNUSED(&BrotliUnalignedRead64);
534 BROTLI_UNUSED(&BrotliUnalignedWrite64);
535 BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD16LE);
536 BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD32LE);
537 BROTLI_UNUSED(&BROTLI_UNALIGNED_LOAD64LE);
538 BROTLI_UNUSED(&BROTLI_UNALIGNED_STORE64LE);
539 BROTLI_UNUSED(&BrotliRBit);
540 BROTLI_UNUSED(&brotli_min_double);
541 BROTLI_UNUSED(&brotli_max_double);
542 BROTLI_UNUSED(&brotli_min_float);
543 BROTLI_UNUSED(&brotli_max_float);
544 BROTLI_UNUSED(&brotli_min_int);
545 BROTLI_UNUSED(&brotli_max_int);
546 BROTLI_UNUSED(&brotli_min_size_t);
547 BROTLI_UNUSED(&brotli_max_size_t);
548 BROTLI_UNUSED(&brotli_min_uint32_t);
549 BROTLI_UNUSED(&brotli_max_uint32_t);
550 BROTLI_UNUSED(&brotli_min_uint8_t);
551 BROTLI_UNUSED(&brotli_max_uint8_t);
552 BROTLI_UNUSED(&BrotliDefaultAllocFunc);
553 BROTLI_UNUSED(&BrotliDefaultFreeFunc);
554 #if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
555 BROTLI_UNUSED(&BrotliDump);
556 #endif
557 }
558
559 #endif /* BROTLI_COMMON_PLATFORM_H_ */
560