1 //===-- sanitizer_platform.h ------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // Common platform macros. 11 //===----------------------------------------------------------------------===// 12 13 #ifndef SANITIZER_PLATFORM_H 14 #define SANITIZER_PLATFORM_H 15 16 #if !defined(__linux__) && !defined(__FreeBSD__) && \ 17 !defined(__APPLE__) && !defined(_WIN32) 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(__APPLE__) 34 # define SANITIZER_MAC 1 35 # include <TargetConditionals.h> 36 # if TARGET_OS_IPHONE 37 # define SANITIZER_IOS 1 38 # else 39 # define SANITIZER_IOS 0 40 # endif 41 # if TARGET_IPHONE_SIMULATOR 42 # define SANITIZER_IOSSIM 1 43 # else 44 # define SANITIZER_IOSSIM 0 45 # endif 46 #else 47 # define SANITIZER_MAC 0 48 # define SANITIZER_IOS 0 49 # define SANITIZER_IOSSIM 0 50 #endif 51 52 #if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_WATCH 53 # define SANITIZER_WATCHOS 1 54 #else 55 # define SANITIZER_WATCHOS 0 56 #endif 57 58 #if defined(__APPLE__) && TARGET_OS_IPHONE && TARGET_OS_TV 59 # define SANITIZER_TVOS 1 60 #else 61 # define SANITIZER_TVOS 0 62 #endif 63 64 #if defined(_WIN32) 65 # define SANITIZER_WINDOWS 1 66 #else 67 # define SANITIZER_WINDOWS 0 68 #endif 69 70 #if defined(_WIN64) 71 # define SANITIZER_WINDOWS64 1 72 #else 73 # define SANITIZER_WINDOWS64 0 74 #endif 75 76 #if defined(__ANDROID__) 77 # define SANITIZER_ANDROID 1 78 #else 79 # define SANITIZER_ANDROID 0 80 #endif 81 82 #define SANITIZER_POSIX (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC) 83 84 #if __LP64__ || defined(_WIN64) 85 # define SANITIZER_WORDSIZE 64 86 #else 87 # define SANITIZER_WORDSIZE 32 88 #endif 89 90 #if SANITIZER_WORDSIZE == 64 91 # define FIRST_32_SECOND_64(a, b) (b) 92 #else 93 # define FIRST_32_SECOND_64(a, b) (a) 94 #endif 95 96 #if defined(__x86_64__) && !defined(_LP64) 97 # define SANITIZER_X32 1 98 #else 99 # define SANITIZER_X32 0 100 #endif 101 102 #if defined(__mips__) 103 # define SANITIZER_MIPS 1 104 # if defined(__mips64) 105 # define SANITIZER_MIPS32 0 106 # define SANITIZER_MIPS64 1 107 # else 108 # define SANITIZER_MIPS32 1 109 # define SANITIZER_MIPS64 0 110 # endif 111 #else 112 # define SANITIZER_MIPS 0 113 # define SANITIZER_MIPS32 0 114 # define SANITIZER_MIPS64 0 115 #endif 116 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 122 # else 123 # define SANITIZER_S390_31 1 124 # define SANITIZER_S390_64 0 125 # endif 126 #else 127 # define SANITIZER_S390 0 128 # define SANITIZER_S390_31 0 129 # define SANITIZER_S390_64 0 130 #endif 131 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. 144 # if _CALL_ELF == 2 145 # define SANITIZER_PPC64V1 0 146 # define SANITIZER_PPC64V2 1 147 # else 148 # define SANITIZER_PPC64V1 1 149 # define SANITIZER_PPC64V2 0 150 # endif 151 # else 152 # define SANITIZER_PPC32 1 153 # define SANITIZER_PPC64 0 154 # define SANITIZER_PPC64V1 0 155 # define SANITIZER_PPC64V2 0 156 # endif 157 #else 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 163 #endif 164 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 defined(__mips64) || defined(__aarch64__) 172 # define SANITIZER_CAN_USE_ALLOCATOR64 0 173 # else 174 # define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64) 175 # endif 176 #endif 177 178 // The range of addresses which can be returned my mmap. 179 // FIXME: this value should be different on different platforms. Larger values 180 // will still work but will consume more memory for TwoLevelByteMap. 181 #if defined(__mips__) 182 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 40) 183 #else 184 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47) 185 #endif 186 187 // The AArch64 linux port uses the canonical syscall set as mandated by 188 // the upstream linux community for all new ports. Other ports may still 189 // use legacy syscalls. 190 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 191 # if defined(__aarch64__) && SANITIZER_LINUX 192 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1 193 # else 194 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0 195 # endif 196 #endif 197 198 // udi16 syscalls can only be used when the following conditions are 199 // met: 200 // * target is one of arm32, x86-32, sparc32, sh or m68k 201 // * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15 202 // built against > linux-2.2 kernel headers 203 // Since we don't want to include libc headers here, we check the 204 // target only. 205 #if defined(__arm__) || SANITIZER_X32 || defined(__sparc__) 206 #define SANITIZER_USES_UID16_SYSCALLS 1 207 #else 208 #define SANITIZER_USES_UID16_SYSCALLS 0 209 #endif 210 211 #if defined(__mips__) 212 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10) 213 #else 214 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 12) 215 #endif 216 217 // Assume obsolete RPC headers are available by default 218 #if !defined(HAVE_RPC_XDR_H) && !defined(HAVE_TIRPC_RPC_XDR_H) 219 # define HAVE_RPC_XDR_H (SANITIZER_LINUX && !SANITIZER_ANDROID) 220 # define HAVE_TIRPC_RPC_XDR_H 0 221 #endif 222 223 /// \macro MSC_PREREQ 224 /// \brief Is the compiler MSVC of at least the specified version? 225 /// The common \param version values to check for are: 226 /// * 1800: Microsoft Visual Studio 2013 / 12.0 227 /// * 1900: Microsoft Visual Studio 2015 / 14.0 228 #ifdef _MSC_VER 229 # define MSC_PREREQ(version) (_MSC_VER >= (version)) 230 #else 231 # define MSC_PREREQ(version) 0 232 #endif 233 234 #if defined(__arm64__) && SANITIZER_IOS 235 # define SANITIZER_NON_UNIQUE_TYPEINFO 1 236 #else 237 # define SANITIZER_NON_UNIQUE_TYPEINFO 0 238 #endif 239 240 // On linux, some architectures had an ABI transition from 64-bit long double 241 // (ie. same as double) to 128-bit long double. On those, glibc symbols 242 // involving long doubles come in two versions, and we need to pass the 243 // correct one to dlvsym when intercepting them. 244 #if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1) 245 #define SANITIZER_NLDBL_VERSION "GLIBC_2.4" 246 #endif 247 248 #endif // SANITIZER_PLATFORM_H 249