compiler-rt/lib/sanitizer_common/sanitizer_platform.h

   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_LINUX) || \
 299       SANITIZER_IOS || 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 << 56)
 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