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