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