1 //===-- sanitizer_platform.h ------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Common platform macros.
11 //===----------------------------------------------------------------------===//
13 #ifndef SANITIZER_PLATFORM_H
14 #define SANITIZER_PLATFORM_H
16 #if !defined(__linux__) && !defined(__FreeBSD__) && \
17 !defined(__APPLE__) && !defined(_WIN32)
18 # error "This operating system is not supported"
21 #if defined(__linux__)
22 # define SANITIZER_LINUX 1
24 # define SANITIZER_LINUX 0
27 #if defined(__FreeBSD__)
28 # define SANITIZER_FREEBSD 1
30 # define SANITIZER_FREEBSD 0
33 #if defined(__APPLE__)
34 # define SANITIZER_MAC 1
35 # include <TargetConditionals.h>
37 # define SANITIZER_IOS 1
39 # define SANITIZER_IOS 0
41 # if TARGET_IPHONE_SIMULATOR
42 # define SANITIZER_IOSSIM 1
44 # define SANITIZER_IOSSIM 0
47 # define SANITIZER_MAC 0
48 # define SANITIZER_IOS 0
49 # define SANITIZER_IOSSIM 0
52 #if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_WATCH
53 # define SANITIZER_WATCHOS 1
55 # define SANITIZER_WATCHOS 0
58 #if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_TV
59 # define SANITIZER_TVOS 1
61 # define SANITIZER_TVOS 0
65 # define SANITIZER_WINDOWS 1
67 # define SANITIZER_WINDOWS 0
71 # define SANITIZER_WINDOWS64 1
73 # define SANITIZER_WINDOWS64 0
76 #if defined(__ANDROID__)
77 # define SANITIZER_ANDROID 1
79 # define SANITIZER_ANDROID 0
82 #define SANITIZER_POSIX (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC)
84 #if __LP64__ || defined(_WIN64)
85 # define SANITIZER_WORDSIZE 64
87 # define SANITIZER_WORDSIZE 32
90 #if SANITIZER_WORDSIZE == 64
91 # define FIRST_32_SECOND_64(a, b) (b)
93 # define FIRST_32_SECOND_64(a, b) (a)
96 #if defined(__x86_64__) && !defined(_LP64)
97 # define SANITIZER_X32 1
99 # define SANITIZER_X32 0
102 #if defined(__mips__)
103 # define SANITIZER_MIPS 1
104 # if defined(__mips64)
105 # define SANITIZER_MIPS32 0
106 # define SANITIZER_MIPS64 1
108 # define SANITIZER_MIPS32 1
109 # define SANITIZER_MIPS64 0
112 # define SANITIZER_MIPS 0
113 # define SANITIZER_MIPS32 0
114 # define SANITIZER_MIPS64 0
117 #if defined(__s390__)
118 # define SANITIZER_S390 1
119 # if defined(__s390x__)
120 # define SANITIZER_S390_31 0
121 # define SANITIZER_S390_64 1
123 # define SANITIZER_S390_31 1
124 # define SANITIZER_S390_64 0
127 # define SANITIZER_S390 0
128 # define SANITIZER_S390_31 0
129 # define SANITIZER_S390_64 0
132 #if defined(__powerpc__)
133 # define SANITIZER_PPC 1
134 # if defined(__powerpc64__)
135 # define SANITIZER_PPC32 0
136 # define SANITIZER_PPC64 1
137 // 64-bit PPC has two ABIs (v1 and v2). The old powerpc64 target is
138 // big-endian, and uses v1 ABI (known for its function descriptors),
139 // while the new powerpc64le target is little-endian and uses v2.
140 // In theory, you could convince gcc to compile for their evil twins
141 // (eg. big-endian v2), but you won't find such combinations in the wild
142 // (it'd require bootstrapping a whole system, which would be quite painful
143 // - there's no target triple for that). LLVM doesn't support them either.
145 # define SANITIZER_PPC64V1 0
146 # define SANITIZER_PPC64V2 1
148 # define SANITIZER_PPC64V1 1
149 # define SANITIZER_PPC64V2 0
152 # define SANITIZER_PPC32 1
153 # define SANITIZER_PPC64 0
154 # define SANITIZER_PPC64V1 0
155 # define SANITIZER_PPC64V2 0
158 # define SANITIZER_PPC 0
159 # define SANITIZER_PPC32 0
160 # define SANITIZER_PPC64 0
161 # define SANITIZER_PPC64V1 0
162 # define SANITIZER_PPC64V2 0
165 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
166 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
167 // does not work well and we need to fallback to SizeClassAllocator32.
168 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
169 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
170 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
171 # if SANITIZER_ANDROID && defined(__aarch64__)
172 # define SANITIZER_CAN_USE_ALLOCATOR64 1
173 # elif defined(__mips64) || defined(__aarch64__)
174 # define SANITIZER_CAN_USE_ALLOCATOR64 0
176 # define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
180 // The range of addresses which can be returned my mmap.
181 // FIXME: this value should be different on different platforms. Larger values
182 // will still work but will consume more memory for TwoLevelByteMap.
183 #if defined(__mips__)
184 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40)
185 #elif defined(__aarch64__)
186 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
188 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
191 // The AArch64 linux port uses the canonical syscall set as mandated by
192 // the upstream linux community for all new ports. Other ports may still
193 // use legacy syscalls.
194 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
195 # if defined(__aarch64__) && SANITIZER_LINUX
196 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
198 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
202 // udi16 syscalls can only be used when the following conditions are
204 // * target is one of arm32, x86-32, sparc32, sh or m68k
205 // * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15
206 // built against > linux-2.2 kernel headers
207 // Since we don't want to include libc headers here, we check the
209 #if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
210 #define SANITIZER_USES_UID16_SYSCALLS 1
212 #define SANITIZER_USES_UID16_SYSCALLS 0
215 #if defined(__mips__)
216 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
218 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12)
221 // Assume obsolete RPC headers are available by default
222 #if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H)
223 # define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID)
224 # define HAVE_TIRPC_RPC_XDR_H 0
227 /// \macro MSC_PREREQ
228 /// \brief Is the compiler MSVC of at least the specified version?
229 /// The common \param version values to check for are:
230 /// * 1800: Microsoft Visual Studio 2013 / 12.0
231 /// * 1900: Microsoft Visual Studio 2015 / 14.0
233 # define MSC_PREREQ(version) (_MSC_VER >= (version))
235 # define MSC_PREREQ(version) 0
238 #if defined(__arm64__) && SANITIZER_IOS
239 # define SANITIZER_NON_UNIQUE_TYPEINFO 1
241 # define SANITIZER_NON_UNIQUE_TYPEINFO 0
244 // On linux, some architectures had an ABI transition from 64-bit long double
245 // (ie. same as double) to 128-bit long double. On those, glibc symbols
246 // involving long doubles come in two versions, and we need to pass the
247 // correct one to dlvsym when intercepting them.
248 #if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1)
249 #define SANITIZER_NLDBL_VERSION "GLIBC_2.4"
252 #if SANITIZER_GO == 0
253 # define SANITIZER_GO 0
256 #endif // SANITIZER_PLATFORM_H