1//===-- sanitizer_internal_defs.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// This file is shared between AddressSanitizer and ThreadSanitizer. 11// It contains macro used in run-time libraries code. 12//===----------------------------------------------------------------------===// 13#ifndef SANITIZER_DEFS_H 14#define SANITIZER_DEFS_H 15 16#include "sanitizer_platform.h" 17 18// Only use SANITIZER_*ATTRIBUTE* before the function return type! 19#if SANITIZER_WINDOWS 20# define SANITIZER_INTERFACE_ATTRIBUTE __declspec(dllexport) 21// FIXME find out what we need on Windows, if anything. 22# define SANITIZER_WEAK_ATTRIBUTE 23#elif defined(SANITIZER_GO) 24# define SANITIZER_INTERFACE_ATTRIBUTE 25# define SANITIZER_WEAK_ATTRIBUTE 26#else 27# define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default"))) 28# define SANITIZER_WEAK_ATTRIBUTE __attribute__((weak)) 29#endif 30 31#if SANITIZER_LINUX && !defined(SANITIZER_GO) 32# define SANITIZER_SUPPORTS_WEAK_HOOKS 1 33#else 34# define SANITIZER_SUPPORTS_WEAK_HOOKS 0 35#endif 36 37// GCC does not understand __has_feature 38#if !defined(__has_feature) 39# define __has_feature(x) 0 40#endif 41 42// For portability reasons we do not include stddef.h, stdint.h or any other 43// system header, but we do need some basic types that are not defined 44// in a portable way by the language itself. 45namespace __sanitizer { 46 47#if defined(_WIN64) 48// 64-bit Windows uses LLP64 data model. 49typedef unsigned long long uptr; // NOLINT 50typedef signed long long sptr; // NOLINT 51#else 52typedef unsigned long uptr; // NOLINT 53typedef signed long sptr; // NOLINT 54#endif // defined(_WIN64) 55#if defined(__x86_64__) 56// Since x32 uses ILP32 data model in 64-bit hardware mode, we must use 57// 64-bit pointer to unwind stack frame. 58typedef unsigned long long uhwptr; // NOLINT 59#else 60typedef uptr uhwptr; // NOLINT 61#endif 62typedef unsigned char u8; 63typedef unsigned short u16; // NOLINT 64typedef unsigned int u32; 65typedef unsigned long long u64; // NOLINT 66typedef signed char s8; 67typedef signed short s16; // NOLINT 68typedef signed int s32; 69typedef signed long long s64; // NOLINT 70typedef int fd_t; 71 72// WARNING: OFF_T may be different from OS type off_t, depending on the value of 73// _FILE_OFFSET_BITS. This definition of OFF_T matches the ABI of system calls 74// like pread and mmap, as opposed to pread64 and mmap64. 75// Mac and Linux/x86-64 are special. 76#if SANITIZER_MAC || (SANITIZER_LINUX && defined(__x86_64__)) 77typedef u64 OFF_T; 78#else 79typedef uptr OFF_T; 80#endif 81typedef u64 OFF64_T; 82 83#if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC 84typedef uptr operator_new_size_type; 85#else 86typedef u32 operator_new_size_type; 87#endif 88} // namespace __sanitizer 89 90extern "C" { 91 // Tell the tools to write their reports to "path.<pid>" instead of stderr. 92 // The special values are "stdout" and "stderr". 93 SANITIZER_INTERFACE_ATTRIBUTE 94 void __sanitizer_set_report_path(const char *path); 95 96 typedef struct { 97 int coverage_sandboxed; 98 __sanitizer::sptr coverage_fd; 99 unsigned int coverage_max_block_size; 100 } __sanitizer_sandbox_arguments; 101 102 // Notify the tools that the sandbox is going to be turned on. 103 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void 104 __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args); 105 106 // This function is called by the tool when it has just finished reporting 107 // an error. 'error_summary' is a one-line string that summarizes 108 // the error message. This function can be overridden by the client. 109 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE 110 void __sanitizer_report_error_summary(const char *error_summary); 111 112 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump(); 113 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_init(); 114 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov(); 115 SANITIZER_INTERFACE_ATTRIBUTE 116 void __sanitizer_annotate_contiguous_container(const void *beg, 117 const void *end, 118 const void *old_mid, 119 const void *new_mid); 120 SANITIZER_INTERFACE_ATTRIBUTE 121 int __sanitizer_verify_contiguous_container(const void *beg, const void *mid, 122 const void *end); 123} // extern "C" 124 125 126using namespace __sanitizer; // NOLINT 127// ----------- ATTENTION ------------- 128// This header should NOT include any other headers to avoid portability issues. 129 130// Common defs. 131#define INLINE inline 132#define INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE 133#define WEAK SANITIZER_WEAK_ATTRIBUTE 134 135// Platform-specific defs. 136#if defined(_MSC_VER) 137# define ALWAYS_INLINE __forceinline 138// FIXME(timurrrr): do we need this on Windows? 139# define ALIAS(x) 140# define ALIGNED(x) __declspec(align(x)) 141# define FORMAT(f, a) 142# define NOINLINE __declspec(noinline) 143# define NORETURN __declspec(noreturn) 144# define THREADLOCAL __declspec(thread) 145# define NOTHROW 146# define LIKELY(x) (x) 147# define UNLIKELY(x) (x) 148# define PREFETCH(x) /* _mm_prefetch(x, _MM_HINT_NTA) */ 149#else // _MSC_VER 150# define ALWAYS_INLINE inline __attribute__((always_inline)) 151# define ALIAS(x) __attribute__((alias(x))) 152// Please only use the ALIGNED macro before the type. 153// Using ALIGNED after the variable declaration is not portable! 154# define ALIGNED(x) __attribute__((aligned(x))) 155# define FORMAT(f, a) __attribute__((format(printf, f, a))) 156# define NOINLINE __attribute__((noinline)) 157# define NORETURN __attribute__((noreturn)) 158# define THREADLOCAL __thread 159# define NOTHROW throw() 160# define LIKELY(x) __builtin_expect(!!(x), 1) 161# define UNLIKELY(x) __builtin_expect(!!(x), 0) 162# if defined(__i386__) || defined(__x86_64__) 163// __builtin_prefetch(x) generates prefetchnt0 on x86 164# define PREFETCH(x) __asm__("prefetchnta (%0)" : : "r" (x)) 165# else 166# define PREFETCH(x) __builtin_prefetch(x) 167# endif 168#endif // _MSC_VER 169 170#if !defined(_MSC_VER) || defined(__clang__) 171# define UNUSED __attribute__((unused)) 172# define USED __attribute__((used)) 173#else 174# define UNUSED 175# define USED 176#endif 177 178// Unaligned versions of basic types. 179typedef ALIGNED(1) u16 uu16; 180typedef ALIGNED(1) u32 uu32; 181typedef ALIGNED(1) u64 uu64; 182typedef ALIGNED(1) s16 us16; 183typedef ALIGNED(1) s32 us32; 184typedef ALIGNED(1) s64 us64; 185 186#if SANITIZER_WINDOWS 187typedef unsigned long DWORD; // NOLINT 188typedef DWORD thread_return_t; 189# define THREAD_CALLING_CONV __stdcall 190#else // _WIN32 191typedef void* thread_return_t; 192# define THREAD_CALLING_CONV 193#endif // _WIN32 194typedef thread_return_t (THREAD_CALLING_CONV *thread_callback_t)(void* arg); 195 196// NOTE: Functions below must be defined in each run-time. 197namespace __sanitizer { 198void NORETURN Die(); 199 200// FIXME: No, this shouldn't be in the sanitizer interface. 201SANITIZER_INTERFACE_ATTRIBUTE 202void NORETURN CheckFailed(const char *file, int line, const char *cond, 203 u64 v1, u64 v2); 204} // namespace __sanitizer 205 206// Check macro 207#define RAW_CHECK_MSG(expr, msg) do { \ 208 if (UNLIKELY(!(expr))) { \ 209 RawWrite(msg); \ 210 Die(); \ 211 } \ 212} while (0) 213 214#define RAW_CHECK(expr) RAW_CHECK_MSG(expr, #expr) 215 216#define CHECK_IMPL(c1, op, c2) \ 217 do { \ 218 __sanitizer::u64 v1 = (u64)(c1); \ 219 __sanitizer::u64 v2 = (u64)(c2); \ 220 if (UNLIKELY(!(v1 op v2))) \ 221 __sanitizer::CheckFailed(__FILE__, __LINE__, \ 222 "(" #c1 ") " #op " (" #c2 ")", v1, v2); \ 223 } while (false) \ 224/**/ 225 226#define CHECK(a) CHECK_IMPL((a), !=, 0) 227#define CHECK_EQ(a, b) CHECK_IMPL((a), ==, (b)) 228#define CHECK_NE(a, b) CHECK_IMPL((a), !=, (b)) 229#define CHECK_LT(a, b) CHECK_IMPL((a), <, (b)) 230#define CHECK_LE(a, b) CHECK_IMPL((a), <=, (b)) 231#define CHECK_GT(a, b) CHECK_IMPL((a), >, (b)) 232#define CHECK_GE(a, b) CHECK_IMPL((a), >=, (b)) 233 234#if TSAN_DEBUG 235#define DCHECK(a) CHECK(a) 236#define DCHECK_EQ(a, b) CHECK_EQ(a, b) 237#define DCHECK_NE(a, b) CHECK_NE(a, b) 238#define DCHECK_LT(a, b) CHECK_LT(a, b) 239#define DCHECK_LE(a, b) CHECK_LE(a, b) 240#define DCHECK_GT(a, b) CHECK_GT(a, b) 241#define DCHECK_GE(a, b) CHECK_GE(a, b) 242#else 243#define DCHECK(a) 244#define DCHECK_EQ(a, b) 245#define DCHECK_NE(a, b) 246#define DCHECK_LT(a, b) 247#define DCHECK_LE(a, b) 248#define DCHECK_GT(a, b) 249#define DCHECK_GE(a, b) 250#endif 251 252#define UNREACHABLE(msg) do { \ 253 CHECK(0 && msg); \ 254 Die(); \ 255} while (0) 256 257#define UNIMPLEMENTED() UNREACHABLE("unimplemented") 258 259#define COMPILER_CHECK(pred) IMPL_COMPILER_ASSERT(pred, __LINE__) 260 261#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) 262 263#define IMPL_PASTE(a, b) a##b 264#define IMPL_COMPILER_ASSERT(pred, line) \ 265 typedef char IMPL_PASTE(assertion_failed_##_, line)[2*(int)(pred)-1] 266 267// Limits for integral types. We have to redefine it in case we don't 268// have stdint.h (like in Visual Studio 9). 269#undef __INT64_C 270#undef __UINT64_C 271#if SANITIZER_WORDSIZE == 64 272# define __INT64_C(c) c ## L 273# define __UINT64_C(c) c ## UL 274#else 275# define __INT64_C(c) c ## LL 276# define __UINT64_C(c) c ## ULL 277#endif // SANITIZER_WORDSIZE == 64 278#undef INT32_MIN 279#define INT32_MIN (-2147483647-1) 280#undef INT32_MAX 281#define INT32_MAX (2147483647) 282#undef UINT32_MAX 283#define UINT32_MAX (4294967295U) 284#undef INT64_MIN 285#define INT64_MIN (-__INT64_C(9223372036854775807)-1) 286#undef INT64_MAX 287#define INT64_MAX (__INT64_C(9223372036854775807)) 288#undef UINT64_MAX 289#define UINT64_MAX (__UINT64_C(18446744073709551615)) 290 291enum LinkerInitialized { LINKER_INITIALIZED = 0 }; 292 293#if !defined(_MSC_VER) || defined(__clang__) 294# define GET_CALLER_PC() (uptr)__builtin_return_address(0) 295# define GET_CURRENT_FRAME() (uptr)__builtin_frame_address(0) 296#else 297extern "C" void* _ReturnAddress(void); 298# pragma intrinsic(_ReturnAddress) 299# define GET_CALLER_PC() (uptr)_ReturnAddress() 300// CaptureStackBackTrace doesn't need to know BP on Windows. 301// FIXME: This macro is still used when printing error reports though it's not 302// clear if the BP value is needed in the ASan reports on Windows. 303# define GET_CURRENT_FRAME() (uptr)0xDEADBEEF 304#endif 305 306#define HANDLE_EINTR(res, f) \ 307 { \ 308 int rverrno; \ 309 do { \ 310 res = (f); \ 311 } while (internal_iserror(res, &rverrno) && rverrno == EINTR); \ 312 } 313 314#endif // SANITIZER_DEFS_H 315