1//===-- sanitizer_platform.h ------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Common platform macros.
10//===----------------------------------------------------------------------===//
11
12#ifndef SANITIZER_PLATFORM_H
13#define SANITIZER_PLATFORM_H
14
15#if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
16 !defined(__APPLE__) && !defined(_WIN32) && !defined(__Fuchsia__) && \
17 !(defined(__sun__) && defined(__svr4__))
18# error "This operating system is not supported"
19#endif
20
21// Get __GLIBC__ on a glibc platform. Exclude Android: features.h includes C
22// function declarations into a .S file which doesn't compile.
23// https://crbug.com/1162741
24#if __has_include(<features.h>) && !defined(__ANDROID__)
25# include <features.h>
26#endif
27
28#if defined(__linux__)
29# define SANITIZER_LINUX 1
30#else
31# define SANITIZER_LINUX 0
32#endif
33
34#if defined(__GLIBC__)
35# define SANITIZER_GLIBC 1
36#else
37# define SANITIZER_GLIBC 0
38#endif
39
40#if defined(__FreeBSD__)
41# define SANITIZER_FREEBSD 1
42#else
43# define SANITIZER_FREEBSD 0
44#endif
45
46#if defined(__NetBSD__)
47# define SANITIZER_NETBSD 1
48#else
49# define SANITIZER_NETBSD 0
50#endif
51
52#if defined(__sun__) && defined(__svr4__)
53# define SANITIZER_SOLARIS 1
54#else
55# define SANITIZER_SOLARIS 0
56#endif
57
58// - SANITIZER_APPLE: all Apple code
59// - TARGET_OS_OSX: macOS
60// - SANITIZER_IOS: devices (iOS and iOS-like)
61// - SANITIZER_WATCHOS
62// - SANITIZER_TVOS
63// - SANITIZER_IOSSIM: simulators (iOS and iOS-like)
64// - SANITIZER_DRIVERKIT
65#if defined(__APPLE__)
66# define SANITIZER_APPLE 1
67# include <TargetConditionals.h>
68# if TARGET_OS_OSX
69# define SANITIZER_OSX 1
70# else
71# define SANITIZER_OSX 0
72# endif
73# if TARGET_OS_IPHONE
74# define SANITIZER_IOS 1
75# else
76# define SANITIZER_IOS 0
77# endif
78# if TARGET_OS_WATCH
79# define SANITIZER_WATCHOS 1
80# else
81# define SANITIZER_WATCHOS 0
82# endif
83# if TARGET_OS_TV
84# define SANITIZER_TVOS 1
85# else
86# define SANITIZER_TVOS 0
87# endif
88# if TARGET_OS_SIMULATOR
89# define SANITIZER_IOSSIM 1
90# else
91# define SANITIZER_IOSSIM 0
92# endif
93# if defined(TARGET_OS_DRIVERKIT) && TARGET_OS_DRIVERKIT
94# define SANITIZER_DRIVERKIT 1
95# else
96# define SANITIZER_DRIVERKIT 0
97# endif
98#else
99# define SANITIZER_APPLE 0
100# define SANITIZER_OSX 0
101# define SANITIZER_IOS 0
102# define SANITIZER_WATCHOS 0
103# define SANITIZER_TVOS 0
104# define SANITIZER_IOSSIM 0
105# define SANITIZER_DRIVERKIT 0
106#endif
107
108#if defined(_WIN32)
109# define SANITIZER_WINDOWS 1
110#else
111# define SANITIZER_WINDOWS 0
112#endif
113
114#if defined(_WIN64)
115# define SANITIZER_WINDOWS64 1
116#else
117# define SANITIZER_WINDOWS64 0
118#endif
119
120#if defined(__ANDROID__)
121# define SANITIZER_ANDROID 1
122#else
123# define SANITIZER_ANDROID 0
124#endif
125
126#if defined(__Fuchsia__)
127# define SANITIZER_FUCHSIA 1
128#else
129# define SANITIZER_FUCHSIA 0
130#endif
131
132// Assume linux that is not glibc or android is musl libc.
133#if SANITIZER_LINUX && !SANITIZER_GLIBC && !SANITIZER_ANDROID
134# define SANITIZER_MUSL 1
135#else
136# define SANITIZER_MUSL 0
137#endif
138
139#define SANITIZER_POSIX \
140 (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_APPLE || \
141 SANITIZER_NETBSD || SANITIZER_SOLARIS)
142
143#if __LP64__ || defined(_WIN64)
144# define SANITIZER_WORDSIZE 64
145#else
146# define SANITIZER_WORDSIZE 32
147#endif
148
149#if SANITIZER_WORDSIZE == 64
150# define FIRST_32_SECOND_64(a, b) (b)
151#else
152# define FIRST_32_SECOND_64(a, b) (a)
153#endif
154
155#if defined(__x86_64__) && !defined(_LP64)
156# define SANITIZER_X32 1
157#else
158# define SANITIZER_X32 0
159#endif
160
161#if defined(__x86_64__) || defined(_M_X64)
162# define SANITIZER_X64 1
163#else
164# define SANITIZER_X64 0
165#endif
166
167#if defined(__i386__) || defined(_M_IX86)
168# define SANITIZER_I386 1
169#else
170# define SANITIZER_I386 0
171#endif
172
173#if defined(__mips__)
174# define SANITIZER_MIPS 1
175# if defined(__mips64) && _MIPS_SIM == _ABI64
176# define SANITIZER_MIPS32 0
177# define SANITIZER_MIPS64 1
178# else
179# define SANITIZER_MIPS32 1
180# define SANITIZER_MIPS64 0
181# endif
182#else
183# define SANITIZER_MIPS 0
184# define SANITIZER_MIPS32 0
185# define SANITIZER_MIPS64 0
186#endif
187
188#if defined(__s390__)
189# define SANITIZER_S390 1
190# if defined(__s390x__)
191# define SANITIZER_S390_31 0
192# define SANITIZER_S390_64 1
193# else
194# define SANITIZER_S390_31 1
195# define SANITIZER_S390_64 0
196# endif
197#else
198# define SANITIZER_S390 0
199# define SANITIZER_S390_31 0
200# define SANITIZER_S390_64 0
201#endif
202
203#if defined(__sparc__)
204# define SANITIZER_SPARC 1
205# if defined(__arch64__)
206# define SANITIZER_SPARC32 0
207# define SANITIZER_SPARC64 1
208# else
209# define SANITIZER_SPARC32 1
210# define SANITIZER_SPARC64 0
211# endif
212#else
213# define SANITIZER_SPARC 0
214# define SANITIZER_SPARC32 0
215# define SANITIZER_SPARC64 0
216#endif
217
218#if defined(__powerpc__)
219# define SANITIZER_PPC 1
220# if defined(__powerpc64__)
221# define SANITIZER_PPC32 0
222# define SANITIZER_PPC64 1
223// 64-bit PPC has two ABIs (v1 and v2). The old powerpc64 target is
224// big-endian, and uses v1 ABI (known for its function descriptors),
225// while the new powerpc64le target is little-endian and uses v2.
226// In theory, you could convince gcc to compile for their evil twins
227// (eg. big-endian v2), but you won't find such combinations in the wild
228// (it'd require bootstrapping a whole system, which would be quite painful
229// - there's no target triple for that). LLVM doesn't support them either.
230# if _CALL_ELF == 2
231# define SANITIZER_PPC64V1 0
232# define SANITIZER_PPC64V2 1
233# else
234# define SANITIZER_PPC64V1 1
235# define SANITIZER_PPC64V2 0
236# endif
237# else
238# define SANITIZER_PPC32 1
239# define SANITIZER_PPC64 0
240# define SANITIZER_PPC64V1 0
241# define SANITIZER_PPC64V2 0
242# endif
243#else
244# define SANITIZER_PPC 0
245# define SANITIZER_PPC32 0
246# define SANITIZER_PPC64 0
247# define SANITIZER_PPC64V1 0
248# define SANITIZER_PPC64V2 0
249#endif
250
251#if defined(__arm__) || defined(_M_ARM)
252# define SANITIZER_ARM 1
253#else
254# define SANITIZER_ARM 0
255#endif
256
257#if defined(__aarch64__) || defined(_M_ARM64)
258# define SANITIZER_ARM64 1
259#else
260# define SANITIZER_ARM64 0
261#endif
262
263#if SANITIZER_WINDOWS64 && SANITIZER_ARM64
264# define SANITIZER_WINDOWS_ARM64 1
265# define SANITIZER_WINDOWS_x64 0
266#elif SANITIZER_WINDOWS64 && !SANITIZER_ARM64
267# define SANITIZER_WINDOWS_ARM64 0
268# define SANITIZER_WINDOWS_x64 1
269#else
270# define SANITIZER_WINDOWS_ARM64 0
271# define SANITIZER_WINDOWS_x64 0
272#endif
273
274#if SANITIZER_SOLARIS && SANITIZER_WORDSIZE == 32
275# define SANITIZER_SOLARIS32 1
276#else
277# define SANITIZER_SOLARIS32 0
278#endif
279
280#if defined(__riscv) && (__riscv_xlen == 64)
281# define SANITIZER_RISCV64 1
282#else
283# define SANITIZER_RISCV64 0
284#endif
285
286#if defined(__loongarch_lp64)
287# define SANITIZER_LOONGARCH64 1
288#else
289# define SANITIZER_LOONGARCH64 0
290#endif
291
292// By default we allow to use SizeClassAllocator64 on 64-bit platform.
293// But in some cases SizeClassAllocator64 does not work well and we need to
294// fallback to SizeClassAllocator32.
295// For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
296// change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
297#ifndef SANITIZER_CAN_USE_ALLOCATOR64
298# if (SANITIZER_RISCV64 && !SANITIZER_FUCHSIA) || SANITIZER_IOS || \
299 SANITIZER_DRIVERKIT
300# define SANITIZER_CAN_USE_ALLOCATOR64 0
301# elif defined(__mips64) || defined(__hexagon__)
302# define SANITIZER_CAN_USE_ALLOCATOR64 0
303# else
304# define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
305# endif
306#endif
307
308// The range of addresses which can be returned my mmap.
309// FIXME: this value should be different on different platforms. Larger values
310// will still work but will consume more memory for TwoLevelByteMap.
311#if defined(__mips__)
312# if SANITIZER_GO && defined(__mips64)
313# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
314# else
315# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
316# endif
317#elif SANITIZER_RISCV64
318// FIXME: Rather than hardcoding the VMA here, we should rely on
319// GetMaxUserVirtualAddress(). This will require some refactoring though since
320// many places either hardcode some value or SANITIZER_MMAP_RANGE_SIZE is
321// assumed to be some constant integer.
322# if SANITIZER_FUCHSIA
323# define SANITIZER_MMAP_RANGE_SIZE (1ULL << 38)
324# else
325# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
326# endif
327#elif defined(__aarch64__)
328# if SANITIZER_APPLE
329# if SANITIZER_OSX || SANITIZER_IOSSIM
330# define SANITIZER_MMAP_RANGE_SIZE \
331 FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
332# else
333// Darwin iOS/ARM64 has a 36-bit VMA, 64GiB VM
334# define SANITIZER_MMAP_RANGE_SIZE \
335 FIRST_32_SECOND_64(1ULL << 32, 1ULL << 36)
336# endif
337# else
338# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
339# endif
340#elif defined(__sparc__)
341# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 52)
342#else
343# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
344#endif
345
346// Whether the addresses are sign-extended from the VMA range to the word.
347// The SPARC64 Linux port implements this to split the VMA space into two
348// non-contiguous halves with a huge hole in the middle.
349#if defined(__sparc__) && SANITIZER_WORDSIZE == 64
350# define SANITIZER_SIGN_EXTENDED_ADDRESSES 1
351#else
352# define SANITIZER_SIGN_EXTENDED_ADDRESSES 0
353#endif
354
355// udi16 syscalls can only be used when the following conditions are
356// met:
357// * target is one of arm32, x86-32, sparc32, sh or m68k
358// * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15
359// built against > linux-2.2 kernel headers
360// Since we don't want to include libc headers here, we check the
361// target only.
362#if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
363# define SANITIZER_USES_UID16_SYSCALLS 1
364#else
365# define SANITIZER_USES_UID16_SYSCALLS 0
366#endif
367
368#if defined(__mips__)
369# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
370#else
371# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
372#endif
373
374/// \macro MSC_PREREQ
375/// \brief Is the compiler MSVC of at least the specified version?
376/// The common \param version values to check for are:
377/// * 1800: Microsoft Visual Studio 2013 / 12.0
378/// * 1900: Microsoft Visual Studio 2015 / 14.0
379#ifdef _MSC_VER
380# define MSC_PREREQ(version) (_MSC_VER >= (version))
381#else
382# define MSC_PREREQ(version) 0
383#endif
384
385#if SANITIZER_APPLE && defined(__x86_64__)
386# define SANITIZER_NON_UNIQUE_TYPEINFO 0
387#else
388# define SANITIZER_NON_UNIQUE_TYPEINFO 1
389#endif
390
391// On linux, some architectures had an ABI transition from 64-bit long double
392// (ie. same as double) to 128-bit long double. On those, glibc symbols
393// involving long doubles come in two versions, and we need to pass the
394// correct one to dlvsym when intercepting them.
395#if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1)
396# define SANITIZER_NLDBL_VERSION "GLIBC_2.4"
397#endif
398
399#if SANITIZER_GO == 0
400# define SANITIZER_GO 0
401#endif
402
403// On PowerPC and ARM Thumb, calling pthread_exit() causes LSan to detect leaks.
404// pthread_exit() performs unwinding that leads to dlopen'ing libgcc_s.so.
405// dlopen mallocs "libgcc_s.so" string which confuses LSan, it fails to realize
406// that this allocation happens in dynamic linker and should be ignored.
407#if SANITIZER_PPC || defined(__thumb__)
408# define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 1
409#else
410# define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 0
411#endif
412
413#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || SANITIZER_SOLARIS
414# define SANITIZER_MADVISE_DONTNEED MADV_FREE
415#else
416# define SANITIZER_MADVISE_DONTNEED MADV_DONTNEED
417#endif
418
419// Older gcc have issues aligning to a constexpr, and require an integer.
420// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56859 among others.
421#if defined(__powerpc__) || defined(__powerpc64__)
422# define SANITIZER_CACHE_LINE_SIZE 128
423#else
424# define SANITIZER_CACHE_LINE_SIZE 64
425#endif
426
427// Enable offline markup symbolizer for Fuchsia.
428#if SANITIZER_FUCHSIA
429# define SANITIZER_SYMBOLIZER_MARKUP 1
430#else
431# define SANITIZER_SYMBOLIZER_MARKUP 0
432#endif
433
434// Enable ability to support sanitizer initialization that is
435// compatible with the sanitizer library being loaded via
436// `dlopen()`.
437#if SANITIZER_APPLE
438# define SANITIZER_SUPPORTS_INIT_FOR_DLOPEN 1
439#else
440# define SANITIZER_SUPPORTS_INIT_FOR_DLOPEN 0
441#endif
442
443// SANITIZER_SUPPORTS_THREADLOCAL
444// 1 - THREADLOCAL macro is supported by target
445// 0 - THREADLOCAL macro is not supported by target
446#ifndef __has_feature
447// TODO: Support other compilers here
448# define SANITIZER_SUPPORTS_THREADLOCAL 1
449#else
450# if __has_feature(tls)
451# define SANITIZER_SUPPORTS_THREADLOCAL 1
452# else
453# define SANITIZER_SUPPORTS_THREADLOCAL 0
454# endif
455#endif
456
457#if defined(__thumb__) && defined(__linux__)
458// Workaround for
459// https://lab.llvm.org/buildbot/#/builders/clang-thumbv7-full-2stage
460// or
461// https://lab.llvm.org/staging/#/builders/clang-thumbv7-full-2stage
462// It fails *rss_limit_mb_test* without meaningful errors.
463# define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL 1
464#else
465# define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL 0
466#endif
467
468#endif // SANITIZER_PLATFORM_H
469

source code of compiler-rt/lib/sanitizer_common/sanitizer_platform.h