sanitizer_platform.h revision 1.8
1//===-- sanitizer_platform.h ------------------------------------*- C++ -*-===// 2// 3// This file is distributed under the University of Illinois Open Source 4// License. See LICENSE.TXT for details. 5// 6//===----------------------------------------------------------------------===// 7// 8// Common platform macros. 9//===----------------------------------------------------------------------===// 10 11#ifndef SANITIZER_PLATFORM_H 12#define SANITIZER_PLATFORM_H 13 14#if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \ 15 !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(_WIN32) && \ 16 !defined(__Fuchsia__) && !defined(__rtems__) && \ 17 !(defined(__sun__) && defined(__svr4__)) 18# error "This operating system is not supported" 19#endif 20 21#if defined(__linux__) 22# define SANITIZER_LINUX 1 23#else 24# define SANITIZER_LINUX 0 25#endif 26 27#if defined(__FreeBSD__) 28# define SANITIZER_FREEBSD 1 29#else 30# define SANITIZER_FREEBSD 0 31#endif 32 33#if defined(__NetBSD__) 34# define SANITIZER_NETBSD 1 35#else 36# define SANITIZER_NETBSD 0 37#endif 38 39#if defined(__OpenBSD__) 40# define SANITIZER_OPENBSD 1 41#else 42# define SANITIZER_OPENBSD 0 43#endif 44 45#if defined(__sun__) && defined(__svr4__) 46# define SANITIZER_SOLARIS 1 47#else 48# define SANITIZER_SOLARIS 0 49#endif 50 51#if defined(__APPLE__) 52# define SANITIZER_MAC 1 53# include <TargetConditionals.h> 54# if TARGET_OS_IPHONE 55# define SANITIZER_IOS 1 56# else 57# define SANITIZER_IOS 0 58# endif 59# if TARGET_OS_SIMULATOR 60# define SANITIZER_IOSSIM 1 61# else 62# define SANITIZER_IOSSIM 0 63# endif 64#else 65# define SANITIZER_MAC 0 66# define SANITIZER_IOS 0 67# define SANITIZER_IOSSIM 0 68#endif 69 70#if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_WATCH 71# define SANITIZER_WATCHOS 1 72#else 73# define SANITIZER_WATCHOS 0 74#endif 75 76#if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_TV 77# define SANITIZER_TVOS 1 78#else 79# define SANITIZER_TVOS 0 80#endif 81 82#if defined(_WIN32) 83# define SANITIZER_WINDOWS 1 84#else 85# define SANITIZER_WINDOWS 0 86#endif 87 88#if defined(_WIN64) 89# define SANITIZER_WINDOWS64 1 90#else 91# define SANITIZER_WINDOWS64 0 92#endif 93 94#if defined(__ANDROID__) 95# define SANITIZER_ANDROID 1 96#else 97# define SANITIZER_ANDROID 0 98#endif 99 100#if defined(__Fuchsia__) 101# define SANITIZER_FUCHSIA 1 102#else 103# define SANITIZER_FUCHSIA 0 104#endif 105 106#if defined(__rtems__) 107# define SANITIZER_RTEMS 1 108#else 109# define SANITIZER_RTEMS 0 110#endif 111 112#define SANITIZER_POSIX \ 113 (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || \ 114 SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_SOLARIS) 115 116#if __LP64__ || defined(_WIN64) 117# define SANITIZER_WORDSIZE 64 118#else 119# define SANITIZER_WORDSIZE 32 120#endif 121 122#if SANITIZER_WORDSIZE == 64 123# define FIRST_32_SECOND_64(a, b) (b) 124#else 125# define FIRST_32_SECOND_64(a, b) (a) 126#endif 127 128#if defined(__x86_64__) && !defined(_LP64) 129# define SANITIZER_X32 1 130#else 131# define SANITIZER_X32 0 132#endif 133 134#if defined(__mips__) 135# define SANITIZER_MIPS 1 136# if defined(__mips64) 137# define SANITIZER_MIPS32 0 138# define SANITIZER_MIPS64 1 139# else 140# define SANITIZER_MIPS32 1 141# define SANITIZER_MIPS64 0 142# endif 143#else 144# define SANITIZER_MIPS 0 145# define SANITIZER_MIPS32 0 146# define SANITIZER_MIPS64 0 147#endif 148 149#if defined(__s390__) 150# define SANITIZER_S390 1 151# if defined(__s390x__) 152# define SANITIZER_S390_31 0 153# define SANITIZER_S390_64 1 154# else 155# define SANITIZER_S390_31 1 156# define SANITIZER_S390_64 0 157# endif 158#else 159# define SANITIZER_S390 0 160# define SANITIZER_S390_31 0 161# define SANITIZER_S390_64 0 162#endif 163 164#if defined(__powerpc__) 165# define SANITIZER_PPC 1 166# if defined(__powerpc64__) 167# define SANITIZER_PPC32 0 168# define SANITIZER_PPC64 1 169// 64-bit PPC has two ABIs (v1 and v2). The old powerpc64 target is 170// big-endian, and uses v1 ABI (known for its function descriptors), 171// while the new powerpc64le target is little-endian and uses v2. 172// In theory, you could convince gcc to compile for their evil twins 173// (eg. big-endian v2), but you won't find such combinations in the wild 174// (it'd require bootstrapping a whole system, which would be quite painful 175// - there's no target triple for that). LLVM doesn't support them either. 176# if _CALL_ELF == 2 177# define SANITIZER_PPC64V1 0 178# define SANITIZER_PPC64V2 1 179# else 180# define SANITIZER_PPC64V1 1 181# define SANITIZER_PPC64V2 0 182# endif 183# else 184# define SANITIZER_PPC32 1 185# define SANITIZER_PPC64 0 186# define SANITIZER_PPC64V1 0 187# define SANITIZER_PPC64V2 0 188# endif 189#else 190# define SANITIZER_PPC 0 191# define SANITIZER_PPC32 0 192# define SANITIZER_PPC64 0 193# define SANITIZER_PPC64V1 0 194# define SANITIZER_PPC64V2 0 195#endif 196 197#if defined(__arm__) 198# define SANITIZER_ARM 1 199#else 200# define SANITIZER_ARM 0 201#endif 202 203#if SANITIZER_SOLARIS && SANITIZER_WORDSIZE == 32 204# define SANITIZER_SOLARIS32 1 205#else 206# define SANITIZER_SOLARIS32 0 207#endif 208 209#if defined(__myriad2__) 210# define SANITIZER_MYRIAD2 1 211#else 212# define SANITIZER_MYRIAD2 0 213#endif 214 215// By default we allow to use SizeClassAllocator64 on 64-bit platform. 216// But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64 217// does not work well and we need to fallback to SizeClassAllocator32. 218// For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or 219// change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here. 220#ifndef SANITIZER_CAN_USE_ALLOCATOR64 221# if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA 222# define SANITIZER_CAN_USE_ALLOCATOR64 1 223# elif defined(__mips64) || defined(__aarch64__) 224# define SANITIZER_CAN_USE_ALLOCATOR64 0 225# else 226# define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64) 227# endif 228#endif 229 230// The range of addresses which can be returned my mmap. 231// FIXME: this value should be different on different platforms. Larger values 232// will still work but will consume more memory for TwoLevelByteMap. 233#if defined(__mips__) 234# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40) 235#elif defined(__aarch64__) 236# if SANITIZER_MAC 237// Darwin iOS/ARM64 has a 36-bit VMA, 64GiB VM 238# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 36) 239# else 240# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48) 241# endif 242#elif defined(__sparc__) 243# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 52) 244#else 245# define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47) 246#endif 247 248// Whether the addresses are sign-extended from the VMA range to the word. 249// The SPARC64 Linux port implements this to split the VMA space into two 250// non-contiguous halves with a huge hole in the middle. 251#if defined(__sparc__) && SANITIZER_WORDSIZE == 64 252# define SANITIZER_SIGN_EXTENDED_ADDRESSES 1 253#else 254# define SANITIZER_SIGN_EXTENDED_ADDRESSES 0 255#endif 256 257// The AArch64 linux port uses the canonical syscall set as mandated by 258// the upstream linux community for all new ports. Other ports may still 259// use legacy syscalls. 260#ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 261# if defined(__aarch64__) && SANITIZER_LINUX 262# define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1 263# else 264# define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0 265# endif 266#endif 267 268// udi16 syscalls can only be used when the following conditions are 269// met: 270// * target is one of arm32, x86-32, sparc32, sh or m68k 271// * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15 272// built against > linux-2.2 kernel headers 273// Since we don't want to include libc headers here, we check the 274// target only. 275#if defined(__arm__) || SANITIZER_X32 || defined(__sparc__) 276#define SANITIZER_USES_UID16_SYSCALLS 1 277#else 278#define SANITIZER_USES_UID16_SYSCALLS 0 279#endif 280 281#if defined(__mips__) 282# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10) 283#else 284# define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12) 285#endif 286 287// Assume obsolete RPC headers are available by default 288#if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H) 289# define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID) 290# define HAVE_TIRPC_RPC_XDR_H 0 291#endif 292 293/// \macro MSC_PREREQ 294/// \brief Is the compiler MSVC of at least the specified version? 295/// The common \param version values to check for are: 296/// * 1800: Microsoft Visual Studio 2013 / 12.0 297/// * 1900: Microsoft Visual Studio 2015 / 14.0 298#ifdef _MSC_VER 299# define MSC_PREREQ(version) (_MSC_VER >= (version)) 300#else 301# define MSC_PREREQ(version) 0 302#endif 303 304#if SANITIZER_MAC && !(defined(__arm64__) && SANITIZER_IOS) 305# define SANITIZER_NON_UNIQUE_TYPEINFO 0 306#else 307# define SANITIZER_NON_UNIQUE_TYPEINFO 1 308#endif 309 310// On linux, some architectures had an ABI transition from 64-bit long double 311// (ie. same as double) to 128-bit long double. On those, glibc symbols 312// involving long doubles come in two versions, and we need to pass the 313// correct one to dlvsym when intercepting them. 314#if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1) 315#define SANITIZER_NLDBL_VERSION "GLIBC_2.4" 316#endif 317 318#if SANITIZER_GO == 0 319# define SANITIZER_GO 0 320#endif 321 322// On PowerPC and ARM Thumb, calling pthread_exit() causes LSan to detect leaks. 323// pthread_exit() performs unwinding that leads to dlopen'ing libgcc_s.so. 324// dlopen mallocs "libgcc_s.so" string which confuses LSan, it fails to realize 325// that this allocation happens in dynamic linker and should be ignored. 326#if SANITIZER_PPC || defined(__thumb__) 327# define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 1 328#else 329# define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 0 330#endif 331 332#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_NETBSD || \ 333 SANITIZER_OPENBSD || SANITIZER_SOLARIS 334# define SANITIZER_MADVISE_DONTNEED MADV_FREE 335#else 336# define SANITIZER_MADVISE_DONTNEED MADV_DONTNEED 337#endif 338 339// Older gcc have issues aligning to a constexpr, and require an integer. 340// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56859 among others. 341#if defined(__powerpc__) || defined(__powerpc64__) 342# define SANITIZER_CACHE_LINE_SIZE 128 343#else 344# define SANITIZER_CACHE_LINE_SIZE 64 345#endif 346 347// Enable offline markup symbolizer for Fuchsia and RTEMS. 348#if SANITIZER_FUCHSIA || SANITIZER_RTEMS 349#define SANITIZER_SYMBOLIZER_MARKUP 1 350#else 351#define SANITIZER_SYMBOLIZER_MARKUP 0 352#endif 353 354#endif // SANITIZER_PLATFORM_H 355