1//===-- sanitizer_internal_defs.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// This file is shared between AddressSanitizer and ThreadSanitizer. 9// It contains macro used in run-time libraries code. 10//===----------------------------------------------------------------------===// 11#ifndef SANITIZER_DEFS_H 12#define SANITIZER_DEFS_H 13 14#include "sanitizer_platform.h" 15 16#ifndef SANITIZER_DEBUG 17# define SANITIZER_DEBUG 0 18#endif 19 20#define SANITIZER_STRINGIFY_(S) #S 21#define SANITIZER_STRINGIFY(S) SANITIZER_STRINGIFY_(S) 22 23// Only use SANITIZER_*ATTRIBUTE* before the function return type! 24#if SANITIZER_WINDOWS 25#if SANITIZER_IMPORT_INTERFACE 26# define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllimport) 27#else 28# define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport) 29#endif 30# define SANITIZER_WEAK_ATTRIBUTE 31#elif SANITIZER_GO 32# define SANITIZER_INTERFACE_ATTRIBUTE 33# define SANITIZER_WEAK_ATTRIBUTE 34#else 35# define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default"))) 36# define SANITIZER_WEAK_ATTRIBUTE __attribute__((weak)) 37#endif 38 39// TLS is handled differently on different platforms 40#if SANITIZER_LINUX || SANITIZER_NETBSD || \ 41 SANITIZER_FREEBSD || SANITIZER_OPENBSD 42# define SANITIZER_TLS_INITIAL_EXEC_ATTRIBUTE \ 43 __attribute__((tls_model("initial-exec"))) thread_local 44#else 45# define SANITIZER_TLS_INITIAL_EXEC_ATTRIBUTE 46#endif 47 48//--------------------------- WEAK FUNCTIONS ---------------------------------// 49// When working with weak functions, to simplify the code and make it more 50// portable, when possible define a default implementation using this macro: 51// 52// SANITIZER_INTERFACE_WEAK_DEF(<return_type>, <name>, <parameter list>) 53// 54// For example: 55// SANITIZER_INTERFACE_WEAK_DEF(bool, compare, int a, int b) { return a > b; } 56// 57#if SANITIZER_WINDOWS 58#include "sanitizer_win_defs.h" 59# define SANITIZER_INTERFACE_WEAK_DEF(ReturnType, Name, ...) \ 60 WIN_WEAK_EXPORT_DEF(ReturnType, Name, __VA_ARGS__) 61#else 62# define SANITIZER_INTERFACE_WEAK_DEF(ReturnType, Name, ...) \ 63 extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE \ 64 ReturnType Name(__VA_ARGS__) 65#endif 66 67// SANITIZER_SUPPORTS_WEAK_HOOKS means that we support real weak functions that 68// will evaluate to a null pointer when not defined. 69#ifndef SANITIZER_SUPPORTS_WEAK_HOOKS 70#if (SANITIZER_LINUX || SANITIZER_NETBSD || SANITIZER_SOLARIS) && !SANITIZER_GO 71# define SANITIZER_SUPPORTS_WEAK_HOOKS 1 72// Before Xcode 4.5, the Darwin linker doesn't reliably support undefined 73// weak symbols. Mac OS X 10.9/Darwin 13 is the first release only supported 74// by Xcode >= 4.5. 75#elif SANITIZER_MAC && \ 76 __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1090 && !SANITIZER_GO 77# define SANITIZER_SUPPORTS_WEAK_HOOKS 1 78#else 79# define SANITIZER_SUPPORTS_WEAK_HOOKS 0 80#endif 81#endif // SANITIZER_SUPPORTS_WEAK_HOOKS 82// For some weak hooks that will be called very often and we want to avoid the 83// overhead of executing the default implementation when it is not necessary, 84// we can use the flag SANITIZER_SUPPORTS_WEAK_HOOKS to only define the default 85// implementation for platforms that doesn't support weak symbols. For example: 86// 87// #if !SANITIZER_SUPPORT_WEAK_HOOKS 88// SANITIZER_INTERFACE_WEAK_DEF(bool, compare_hook, int a, int b) { 89// return a > b; 90// } 91// #endif 92// 93// And then use it as: if (compare_hook) compare_hook(a, b); 94//----------------------------------------------------------------------------// 95 96 97// We can use .preinit_array section on Linux to call sanitizer initialization 98// functions very early in the process startup (unless PIC macro is defined). 99// 100// On FreeBSD, .preinit_array functions are called with rtld_bind_lock writer 101// lock held. It will lead to dead lock if unresolved PLT functions (which helds 102// rtld_bind_lock reader lock) are called inside .preinit_array functions. 103// 104// FIXME: do we have anything like this on Mac? 105#ifndef SANITIZER_CAN_USE_PREINIT_ARRAY 106#if ((SANITIZER_LINUX && !SANITIZER_ANDROID) || SANITIZER_OPENBSD || \ 107 SANITIZER_FUCHSIA || SANITIZER_NETBSD) && !defined(PIC) 108#define SANITIZER_CAN_USE_PREINIT_ARRAY 1 109// Before Solaris 11.4, .preinit_array is fully supported only with GNU ld. 110// FIXME: Check for those conditions. 111#elif SANITIZER_SOLARIS && !defined(PIC) 112# define SANITIZER_CAN_USE_PREINIT_ARRAY 1 113#else 114# define SANITIZER_CAN_USE_PREINIT_ARRAY 0 115#endif 116#endif // SANITIZER_CAN_USE_PREINIT_ARRAY 117 118// GCC does not understand __has_feature 119#if !defined(__has_feature) 120# define __has_feature(x) 0 121#endif 122 123// Outside of namespace below as we need <sys/types.h> 124#if SANITIZER_NETBSD 125#include <sys/types.h> 126#endif 127 128// Older GCCs do not understand __has_attribute. 129#if !defined(__has_attribute) 130# define __has_attribute(x) 0 131#endif 132 133// For portability reasons we do not include stddef.h, stdint.h or any other 134// system header, but we do need some basic types that are not defined 135// in a portable way by the language itself. 136namespace __sanitizer { 137 138#if defined(_WIN64) 139// 64-bit Windows uses LLP64 data model. 140typedef unsigned long long uptr; // NOLINT 141typedef signed long long sptr; // NOLINT 142#else 143typedef unsigned long uptr; // NOLINT 144typedef signed long sptr; // NOLINT 145#endif // defined(_WIN64) 146#if defined(__x86_64__) 147// Since x32 uses ILP32 data model in 64-bit hardware mode, we must use 148// 64-bit pointer to unwind stack frame. 149typedef unsigned long long uhwptr; // NOLINT 150#else 151typedef uptr uhwptr; // NOLINT 152#endif 153typedef unsigned char u8; 154typedef unsigned short u16; // NOLINT 155typedef unsigned int u32; 156typedef unsigned long long u64; // NOLINT 157typedef signed char s8; 158typedef signed short s16; // NOLINT 159typedef signed int s32; 160typedef signed long long s64; // NOLINT 161#if SANITIZER_WINDOWS 162// On Windows, files are HANDLE, which is a synonim of void*. 163// Use void* to avoid including <windows.h> everywhere. 164typedef void* fd_t; 165typedef unsigned error_t; 166#else 167typedef int fd_t; 168typedef int error_t; 169#endif 170#if SANITIZER_SOLARIS && !defined(_LP64) 171typedef long pid_t; 172#else 173typedef int pid_t; 174#endif 175 176#if SANITIZER_FREEBSD || SANITIZER_NETBSD || \ 177 SANITIZER_OPENBSD || SANITIZER_MAC || \ 178 (SANITIZER_SOLARIS && (defined(_LP64) || _FILE_OFFSET_BITS == 64)) || \ 179 (SANITIZER_LINUX && defined(__x86_64__)) 180typedef u64 OFF_T; 181#else 182typedef uptr OFF_T; 183#endif 184typedef u64 OFF64_T; 185 186#if SANITIZER_NETBSD 187typedef size_t operator_new_size_type; 188#else 189#if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC 190typedef uptr operator_new_size_type; 191#else 192# if SANITIZER_OPENBSD || defined(__s390__) && !defined(__s390x__) 193// Special case: 31-bit s390 has unsigned long as size_t. 194typedef unsigned long operator_new_size_type; 195# else 196typedef u32 operator_new_size_type; 197# endif 198#endif 199#endif 200 201typedef u64 tid_t; 202 203// ----------- ATTENTION ------------- 204// This header should NOT include any other headers to avoid portability issues. 205 206// Common defs. 207#ifndef INLINE 208#define INLINE inline 209#endif 210#define INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE 211#define SANITIZER_WEAK_DEFAULT_IMPL \ 212 extern "C" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE 213#define SANITIZER_WEAK_CXX_DEFAULT_IMPL \ 214 extern "C++" SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE NOINLINE 215 216// Platform-specific defs. 217#if defined(_MSC_VER) 218# define ALWAYS_INLINE __forceinline 219// FIXME(timurrrr): do we need this on Windows? 220# define ALIAS(x) 221# define ALIGNED(x) __declspec(align(x)) 222# define FORMAT(f, a) 223# define NOINLINE __declspec(noinline) 224# define NORETURN __declspec(noreturn) 225# define THREADLOCAL __declspec(thread) 226# define LIKELY(x) (x) 227# define UNLIKELY(x) (x) 228# define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */ (void)0 229# define WARN_UNUSED_RESULT 230#else // _MSC_VER 231# define ALWAYS_INLINE inline __attribute__((always_inline)) 232# define ALIAS(x) __attribute__((alias(x))) 233// Please only use the ALIGNED macro before the type. 234// Using ALIGNED after the variable declaration is not portable! 235# define ALIGNED(x) __attribute__((aligned(x))) 236# define FORMAT(f, a) __attribute__((format(printf, f, a))) 237# define NOINLINE __attribute__((noinline)) 238# define NORETURN __attribute__((noreturn)) 239# define THREADLOCAL __thread 240# define LIKELY(x) __builtin_expect(!!(x), 1) 241# define UNLIKELY(x) __builtin_expect(!!(x), 0) 242# if defined(__i386__) || defined(__x86_64__) 243// __builtin_prefetch(x) generates prefetchnt0 on x86 244# define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x)) 245# else 246# define PREFETCH(x) __builtin_prefetch(x) 247# endif 248# define WARN_UNUSED_RESULT __attribute__((warn_unused_result)) 249#endif // _MSC_VER 250 251#if !defined(_MSC_VER) || defined(__clang__) 252# define UNUSED __attribute__((unused)) 253# define USED __attribute__((used)) 254#else 255# define UNUSED 256# define USED 257#endif 258 259#if !defined(_MSC_VER) || defined(__clang__) || MSC_PREREQ(1900) 260# define NOEXCEPT noexcept 261#else 262# define NOEXCEPT throw() 263#endif 264 265// Unaligned versions of basic types. 266typedef ALIGNED(1) u16 uu16; 267typedef ALIGNED(1) u32 uu32; 268typedef ALIGNED(1) u64 uu64; 269typedef ALIGNED(1) s16 us16; 270typedef ALIGNED(1) s32 us32; 271typedef ALIGNED(1) s64 us64; 272 273#if SANITIZER_WINDOWS 274} // namespace __sanitizer 275typedef unsigned long DWORD; // NOLINT 276namespace __sanitizer { 277typedef DWORD thread_return_t; 278# define THREAD_CALLING_CONV __stdcall 279#else // _WIN32 280typedef void* thread_return_t; 281# define THREAD_CALLING_CONV 282#endif // _WIN32 283typedef thread_return_t (THREAD_CALLING_CONV *thread_callback_t)(void* arg); 284 285// NOTE: Functions below must be defined in each run-time. 286void NORETURN Die(); 287 288void NORETURN CheckFailed(const char *file, int line, const char *cond, 289 u64 v1, u64 v2); 290 291// Check macro 292#define RAW_CHECK_MSG(expr, msg) do { \ 293 if (UNLIKELY(!(expr))) { \ 294 RawWrite(msg); \ 295 Die(); \ 296 } \ 297} while (0) 298 299#define RAW_CHECK(expr) RAW_CHECK_MSG(expr, #expr) 300 301#define CHECK_IMPL(c1, op, c2) \ 302 do { \ 303 __sanitizer::u64 v1 = (__sanitizer::u64)(c1); \ 304 __sanitizer::u64 v2 = (__sanitizer::u64)(c2); \ 305 if (UNLIKELY(!(v1 op v2))) \ 306 __sanitizer::CheckFailed(__FILE__, __LINE__, \ 307 "(" #c1 ") " #op " (" #c2 ")", v1, v2); \ 308 } while (false) \ 309/**/ 310 311#define CHECK(a) CHECK_IMPL((a), !=, 0) 312#define CHECK_EQ(a, b) CHECK_IMPL((a), ==, (b)) 313#define CHECK_NE(a, b) CHECK_IMPL((a), !=, (b)) 314#define CHECK_LT(a, b) CHECK_IMPL((a), <, (b)) 315#define CHECK_LE(a, b) CHECK_IMPL((a), <=, (b)) 316#define CHECK_GT(a, b) CHECK_IMPL((a), >, (b)) 317#define CHECK_GE(a, b) CHECK_IMPL((a), >=, (b)) 318 319#if SANITIZER_DEBUG 320#define DCHECK(a) CHECK(a) 321#define DCHECK_EQ(a, b) CHECK_EQ(a, b) 322#define DCHECK_NE(a, b) CHECK_NE(a, b) 323#define DCHECK_LT(a, b) CHECK_LT(a, b) 324#define DCHECK_LE(a, b) CHECK_LE(a, b) 325#define DCHECK_GT(a, b) CHECK_GT(a, b) 326#define DCHECK_GE(a, b) CHECK_GE(a, b) 327#else 328#define DCHECK(a) 329#define DCHECK_EQ(a, b) 330#define DCHECK_NE(a, b) 331#define DCHECK_LT(a, b) 332#define DCHECK_LE(a, b) 333#define DCHECK_GT(a, b) 334#define DCHECK_GE(a, b) 335#endif 336 337#define UNREACHABLE(msg) do { \ 338 CHECK(0 && msg); \ 339 Die(); \ 340} while (0) 341 342#define UNIMPLEMENTED() UNREACHABLE("unimplemented") 343 344#define COMPILER_CHECK(pred) IMPL_COMPILER_ASSERT(pred, __LINE__) 345 346#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) 347 348#define IMPL_PASTE(a, b) a##b 349#define IMPL_COMPILER_ASSERT(pred, line) \ 350 typedef char IMPL_PASTE(assertion_failed_##_, line)[2*(int)(pred)-1] 351 352// Limits for integral types. We have to redefine it in case we don't 353// have stdint.h (like in Visual Studio 9). 354#undef __INT64_C 355#undef __UINT64_C 356#if SANITIZER_WORDSIZE == 64 357# define __INT64_C(c) c ## L 358# define __UINT64_C(c) c ## UL 359#else 360# define __INT64_C(c) c ## LL 361# define __UINT64_C(c) c ## ULL 362#endif // SANITIZER_WORDSIZE == 64 363#undef INT32_MIN 364#define INT32_MIN (-2147483647-1) 365#undef INT32_MAX 366#define INT32_MAX (2147483647) 367#undef UINT32_MAX 368#define UINT32_MAX (4294967295U) 369#undef INT64_MIN 370#define INT64_MIN (-__INT64_C(9223372036854775807)-1) 371#undef INT64_MAX 372#define INT64_MAX (__INT64_C(9223372036854775807)) 373#undef UINT64_MAX 374#define UINT64_MAX (__UINT64_C(18446744073709551615)) 375#undef UINTPTR_MAX 376#if SANITIZER_WORDSIZE == 64 377# define UINTPTR_MAX (18446744073709551615UL) 378#else 379# define UINTPTR_MAX (4294967295U) 380#endif // SANITIZER_WORDSIZE == 64 381 382enum LinkerInitialized { LINKER_INITIALIZED = 0 }; 383 384#if !defined(_MSC_VER) || defined(__clang__) 385#if SANITIZER_S390_31 386#define GET_CALLER_PC() \ 387 (__sanitizer::uptr) __builtin_extract_return_addr(__builtin_return_address(0)) 388#else 389#define GET_CALLER_PC() (__sanitizer::uptr) __builtin_return_address(0) 390#endif 391#define GET_CURRENT_FRAME() (__sanitizer::uptr) __builtin_frame_address(0) 392inline void Trap() { 393 __builtin_trap(); 394} 395#else 396extern "C" void* _ReturnAddress(void); 397extern "C" void* _AddressOfReturnAddress(void); 398# pragma intrinsic(_ReturnAddress) 399# pragma intrinsic(_AddressOfReturnAddress) 400#define GET_CALLER_PC() (__sanitizer::uptr) _ReturnAddress() 401// CaptureStackBackTrace doesn't need to know BP on Windows. 402#define GET_CURRENT_FRAME() \ 403 (((__sanitizer::uptr)_AddressOfReturnAddress()) + sizeof(__sanitizer::uptr)) 404 405extern "C" void __ud2(void); 406# pragma intrinsic(__ud2) 407inline void Trap() { 408 __ud2(); 409} 410#endif 411 412#define HANDLE_EINTR(res, f) \ 413 { \ 414 int rverrno; \ 415 do { \ 416 res = (f); \ 417 } while (internal_iserror(res, &rverrno) && rverrno == EINTR); \ 418 } 419 420// Forces the compiler to generate a frame pointer in the function. 421#define ENABLE_FRAME_POINTER \ 422 do { \ 423 volatile __sanitizer::uptr enable_fp; \ 424 enable_fp = GET_CURRENT_FRAME(); \ 425 (void)enable_fp; \ 426 } while (0) 427 428} // namespace __sanitizer 429 430namespace __asan { using namespace __sanitizer; } // NOLINT 431namespace __dsan { using namespace __sanitizer; } // NOLINT 432namespace __dfsan { using namespace __sanitizer; } // NOLINT 433namespace __esan { using namespace __sanitizer; } // NOLINT 434namespace __lsan { using namespace __sanitizer; } // NOLINT 435namespace __msan { using namespace __sanitizer; } // NOLINT 436namespace __hwasan { using namespace __sanitizer; } // NOLINT 437namespace __tsan { using namespace __sanitizer; } // NOLINT 438namespace __scudo { using namespace __sanitizer; } // NOLINT 439namespace __ubsan { using namespace __sanitizer; } // NOLINT 440namespace __xray { using namespace __sanitizer; } // NOLINT 441namespace __interception { using namespace __sanitizer; } // NOLINT 442namespace __hwasan { using namespace __sanitizer; } // NOLINT 443 444 445#endif // SANITIZER_DEFS_H 446