//===-- sanitizer_platform.h ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Common platform macros. //===----------------------------------------------------------------------===// #ifndef SANITIZER_PLATFORM_H #define SANITIZER_PLATFORM_H #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \ !defined(__APPLE__) && !defined(_WIN32) && !defined(__Fuchsia__) && \ !(defined(__sun__) && defined(__svr4__)) # error "This operating system is not supported" #endif // Get __GLIBC__ on a glibc platform. Exclude Android: features.h includes C // function declarations into a .S file which doesn't compile. // https://crbug.com/1162741 #if __has_include(<features.h>) && !defined(__ANDROID__) # include <features.h> #endif #if defined(__linux__) #define SANITIZER_LINUX … #else #define SANITIZER_LINUX … #endif #if defined(__GLIBC__) #define SANITIZER_GLIBC … #else #define SANITIZER_GLIBC … #endif #if defined(__FreeBSD__) #define SANITIZER_FREEBSD … #else #define SANITIZER_FREEBSD … #endif #if defined(__NetBSD__) #define SANITIZER_NETBSD … #else #define SANITIZER_NETBSD … #endif #if defined(__sun__) && defined(__svr4__) #define SANITIZER_SOLARIS … #else #define SANITIZER_SOLARIS … #endif // - SANITIZER_APPLE: all Apple code // - TARGET_OS_OSX: macOS // - SANITIZER_IOS: devices (iOS and iOS-like) // - SANITIZER_WATCHOS // - SANITIZER_TVOS // - SANITIZER_IOSSIM: simulators (iOS and iOS-like) // - SANITIZER_DRIVERKIT #if defined(__APPLE__) #define SANITIZER_APPLE … # include <TargetConditionals.h> # if TARGET_OS_OSX #define SANITIZER_OSX … # else #define SANITIZER_OSX … # endif # if TARGET_OS_IPHONE #define SANITIZER_IOS … # else #define SANITIZER_IOS … # endif # if TARGET_OS_WATCH #define SANITIZER_WATCHOS … # else #define SANITIZER_WATCHOS … # endif # if TARGET_OS_TV #define SANITIZER_TVOS … # else #define SANITIZER_TVOS … # endif # if TARGET_OS_SIMULATOR #define SANITIZER_IOSSIM … # else #define SANITIZER_IOSSIM … # endif # if defined(TARGET_OS_DRIVERKIT) && TARGET_OS_DRIVERKIT #define SANITIZER_DRIVERKIT … # else #define SANITIZER_DRIVERKIT … # endif #else #define SANITIZER_APPLE … #define SANITIZER_OSX … #define SANITIZER_IOS … #define SANITIZER_WATCHOS … #define SANITIZER_TVOS … #define SANITIZER_IOSSIM … #define SANITIZER_DRIVERKIT … #endif #if defined(_WIN32) #define SANITIZER_WINDOWS … #else #define SANITIZER_WINDOWS … #endif #if defined(_WIN64) #define SANITIZER_WINDOWS64 … #else #define SANITIZER_WINDOWS64 … #endif #if defined(__ANDROID__) #define SANITIZER_ANDROID … #else #define SANITIZER_ANDROID … #endif #if defined(__Fuchsia__) #define SANITIZER_FUCHSIA … #else #define SANITIZER_FUCHSIA … #endif // Assume linux that is not glibc or android is musl libc. #if SANITIZER_LINUX && !SANITIZER_GLIBC && !SANITIZER_ANDROID #define SANITIZER_MUSL … #else #define SANITIZER_MUSL … #endif #define SANITIZER_POSIX … #if __LP64__ || defined(_WIN64) #define SANITIZER_WORDSIZE … #else #define SANITIZER_WORDSIZE … #endif #if SANITIZER_WORDSIZE == 64 #define FIRST_32_SECOND_64(a, b) … #else #define FIRST_32_SECOND_64 … #endif #if defined(__x86_64__) && !defined(_LP64) #define SANITIZER_X32 … #else #define SANITIZER_X32 … #endif #if defined(__x86_64__) || defined(_M_X64) #define SANITIZER_X64 … #else #define SANITIZER_X64 … #endif #if defined(__i386__) || defined(_M_IX86) #define SANITIZER_I386 … #else #define SANITIZER_I386 … #endif #if defined(__mips__) #define SANITIZER_MIPS … # if defined(__mips64) && _MIPS_SIM == _ABI64 #define SANITIZER_MIPS32 … #define SANITIZER_MIPS64 … # else #define SANITIZER_MIPS32 … #define SANITIZER_MIPS64 … # endif #else #define SANITIZER_MIPS … #define SANITIZER_MIPS32 … #define SANITIZER_MIPS64 … #endif #if defined(__s390__) #define SANITIZER_S390 … # if defined(__s390x__) #define SANITIZER_S390_31 … #define SANITIZER_S390_64 … # else #define SANITIZER_S390_31 … #define SANITIZER_S390_64 … # endif #else #define SANITIZER_S390 … #define SANITIZER_S390_31 … #define SANITIZER_S390_64 … #endif #if defined(__sparc__) #define SANITIZER_SPARC … # if defined(__arch64__) #define SANITIZER_SPARC32 … #define SANITIZER_SPARC64 … # else #define SANITIZER_SPARC32 … #define SANITIZER_SPARC64 … # endif #else #define SANITIZER_SPARC … #define SANITIZER_SPARC32 … #define SANITIZER_SPARC64 … #endif #if defined(__powerpc__) #define SANITIZER_PPC … # if defined(__powerpc64__) #define SANITIZER_PPC32 … #define SANITIZER_PPC64 … // 64-bit PPC has two ABIs (v1 and v2). The old powerpc64 target is // big-endian, and uses v1 ABI (known for its function descriptors), // while the new powerpc64le target is little-endian and uses v2. // In theory, you could convince gcc to compile for their evil twins // (eg. big-endian v2), but you won't find such combinations in the wild // (it'd require bootstrapping a whole system, which would be quite painful // - there's no target triple for that). LLVM doesn't support them either. # if _CALL_ELF == 2 #define SANITIZER_PPC64V1 … #define SANITIZER_PPC64V2 … # else #define SANITIZER_PPC64V1 … #define SANITIZER_PPC64V2 … # endif # else #define SANITIZER_PPC32 … #define SANITIZER_PPC64 … #define SANITIZER_PPC64V1 … #define SANITIZER_PPC64V2 … # endif #else #define SANITIZER_PPC … #define SANITIZER_PPC32 … #define SANITIZER_PPC64 … #define SANITIZER_PPC64V1 … #define SANITIZER_PPC64V2 … #endif #if defined(__arm__) || defined(_M_ARM) #define SANITIZER_ARM … #else #define SANITIZER_ARM … #endif #if defined(__aarch64__) || defined(_M_ARM64) #define SANITIZER_ARM64 … #else #define SANITIZER_ARM64 … #endif #if SANITIZER_WINDOWS64 && SANITIZER_ARM64 #define SANITIZER_WINDOWS_ARM64 … #define SANITIZER_WINDOWS_x64 … #elif SANITIZER_WINDOWS64 && !SANITIZER_ARM64 #define SANITIZER_WINDOWS_ARM64 … #define SANITIZER_WINDOWS_x64 … #else #define SANITIZER_WINDOWS_ARM64 … #define SANITIZER_WINDOWS_x64 … #endif #if SANITIZER_SOLARIS && SANITIZER_WORDSIZE == 32 #define SANITIZER_SOLARIS32 … #else #define SANITIZER_SOLARIS32 … #endif #if defined(__riscv) && (__riscv_xlen == 64) #define SANITIZER_RISCV64 … #else #define SANITIZER_RISCV64 … #endif #if defined(__loongarch_lp64) #define SANITIZER_LOONGARCH64 … #else #define SANITIZER_LOONGARCH64 … #endif // By default we allow to use SizeClassAllocator64 on 64-bit platform. // But in some cases SizeClassAllocator64 does not work well and we need to // fallback to SizeClassAllocator32. // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here. #ifndef SANITIZER_CAN_USE_ALLOCATOR64 # if (SANITIZER_RISCV64 && !SANITIZER_FUCHSIA && !SANITIZER_LINUX) || \ SANITIZER_IOS || SANITIZER_DRIVERKIT #define SANITIZER_CAN_USE_ALLOCATOR64 … # elif defined(__mips64) || defined(__hexagon__) #define SANITIZER_CAN_USE_ALLOCATOR64 … # else #define SANITIZER_CAN_USE_ALLOCATOR64 … # endif #endif // The range of addresses which can be returned my mmap. // FIXME: this value should be different on different platforms. Larger values // will still work but will consume more memory for TwoLevelByteMap. #if defined(__mips__) # if SANITIZER_GO && defined(__mips64) #define SANITIZER_MMAP_RANGE_SIZE … # else #define SANITIZER_MMAP_RANGE_SIZE … # endif #elif SANITIZER_RISCV64 // FIXME: Rather than hardcoding the VMA here, we should rely on // GetMaxUserVirtualAddress(). This will require some refactoring though since // many places either hardcode some value or SANITIZER_MMAP_RANGE_SIZE is // assumed to be some constant integer. # if SANITIZER_FUCHSIA #define SANITIZER_MMAP_RANGE_SIZE … # else #define SANITIZER_MMAP_RANGE_SIZE … # endif #elif defined(__aarch64__) # if SANITIZER_APPLE # if SANITIZER_OSX || SANITIZER_IOSSIM #define SANITIZER_MMAP_RANGE_SIZE … # else // Darwin iOS/ARM64 has a 36-bit VMA, 64GiB VM #define SANITIZER_MMAP_RANGE_SIZE … # endif # else #define SANITIZER_MMAP_RANGE_SIZE … # endif #elif defined(__sparc__) #define SANITIZER_MMAP_RANGE_SIZE … #else #define SANITIZER_MMAP_RANGE_SIZE … #endif // Whether the addresses are sign-extended from the VMA range to the word. // The SPARC64 Linux port implements this to split the VMA space into two // non-contiguous halves with a huge hole in the middle. #if defined(__sparc__) && SANITIZER_WORDSIZE == 64 #define SANITIZER_SIGN_EXTENDED_ADDRESSES … #else #define SANITIZER_SIGN_EXTENDED_ADDRESSES … #endif // udi16 syscalls can only be used when the following conditions are // met: // * target is one of arm32, x86-32, sparc32, sh or m68k // * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15 // built against > linux-2.2 kernel headers // Since we don't want to include libc headers here, we check the // target only. #if defined(__arm__) || SANITIZER_X32 || defined(__sparc__) #define SANITIZER_USES_UID16_SYSCALLS … #else #define SANITIZER_USES_UID16_SYSCALLS … #endif #if defined(__mips__) #define SANITIZER_POINTER_FORMAT_LENGTH … #else #define SANITIZER_POINTER_FORMAT_LENGTH … #endif /// \macro MSC_PREREQ /// \brief Is the compiler MSVC of at least the specified version? /// The common \param version values to check for are: /// * 1800: Microsoft Visual Studio 2013 / 12.0 /// * 1900: Microsoft Visual Studio 2015 / 14.0 #ifdef _MSC_VER #define MSC_PREREQ … #else #define MSC_PREREQ(version) … #endif #if SANITIZER_APPLE && defined(__x86_64__) #define SANITIZER_NON_UNIQUE_TYPEINFO … #else #define SANITIZER_NON_UNIQUE_TYPEINFO … #endif // On linux, some architectures had an ABI transition from 64-bit long double // (ie. same as double) to 128-bit long double. On those, glibc symbols // involving long doubles come in two versions, and we need to pass the // correct one to dlvsym when intercepting them. #if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1) #define SANITIZER_NLDBL_VERSION … #endif #if SANITIZER_GO == 0 #define SANITIZER_GO … #endif // On PowerPC and ARM Thumb, calling pthread_exit() causes LSan to detect leaks. // pthread_exit() performs unwinding that leads to dlopen'ing libgcc_s.so. // dlopen mallocs "libgcc_s.so" string which confuses LSan, it fails to realize // that this allocation happens in dynamic linker and should be ignored. #if SANITIZER_PPC || defined(__thumb__) #define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT … #else #define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT … #endif #if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || SANITIZER_SOLARIS #define SANITIZER_MADVISE_DONTNEED … #else #define SANITIZER_MADVISE_DONTNEED … #endif // Older gcc have issues aligning to a constexpr, and require an integer. // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56859 among others. #if defined(__powerpc__) || defined(__powerpc64__) #define SANITIZER_CACHE_LINE_SIZE … #else #define SANITIZER_CACHE_LINE_SIZE … #endif // Enable offline markup symbolizer for Fuchsia. #if SANITIZER_FUCHSIA #define SANITIZER_SYMBOLIZER_MARKUP … #else #define SANITIZER_SYMBOLIZER_MARKUP … #endif // Enable ability to support sanitizer initialization that is // compatible with the sanitizer library being loaded via // `dlopen()`. #if SANITIZER_APPLE #define SANITIZER_SUPPORTS_INIT_FOR_DLOPEN … #else #define SANITIZER_SUPPORTS_INIT_FOR_DLOPEN … #endif // SANITIZER_SUPPORTS_THREADLOCAL // 1 - THREADLOCAL macro is supported by target // 0 - THREADLOCAL macro is not supported by target #ifndef __has_feature // TODO: Support other compilers here #define SANITIZER_SUPPORTS_THREADLOCAL … #else # if __has_feature(tls) #define SANITIZER_SUPPORTS_THREADLOCAL … # else #define SANITIZER_SUPPORTS_THREADLOCAL … # endif #endif #if defined(__thumb__) && defined(__linux__) // Workaround for // https://lab.llvm.org/buildbot/#/builders/clang-thumbv7-full-2stage // or // https://lab.llvm.org/staging/#/builders/clang-thumbv7-full-2stage // It fails *rss_limit_mb_test* without meaningful errors. #define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL … #else #define SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL … #endif #endif // SANITIZER_PLATFORM_H
Codebase Browser
llvm