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