sanitizer_common.h revision e0023f74ea88efee329f68391b70f8adc6b21617
1//===-- sanitizer_common.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// run-time libraries. 12// It declares common functions and classes that are used in both runtimes. 13// Implementation of some functions are provided in sanitizer_common, while 14// others must be defined by run-time library itself. 15//===----------------------------------------------------------------------===// 16#ifndef SANITIZER_COMMON_H 17#define SANITIZER_COMMON_H 18 19#include "sanitizer_internal_defs.h" 20 21namespace __sanitizer { 22 23// Constants. 24const uptr kWordSize = __WORDSIZE / 8; 25const uptr kWordSizeInBits = 8 * kWordSize; 26const uptr kPageSizeBits = 12; 27const uptr kPageSize = 1UL << kPageSizeBits; 28const uptr kCacheLineSize = 64; 29#ifndef _WIN32 30const uptr kMmapGranularity = kPageSize; 31#else 32const uptr kMmapGranularity = 1UL << 16; 33#endif 34 35// Threads 36int GetPid(); 37uptr GetTid(); 38uptr GetThreadSelf(); 39void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top, 40 uptr *stack_bottom); 41 42// Memory management 43void *MmapOrDie(uptr size, const char *mem_type); 44void UnmapOrDie(void *addr, uptr size); 45void *MmapFixedNoReserve(uptr fixed_addr, uptr size); 46void *Mprotect(uptr fixed_addr, uptr size); 47// Used to check if we can map shadow memory to a fixed location. 48bool MemoryRangeIsAvailable(uptr range_start, uptr range_end); 49 50// Internal allocator 51void *InternalAlloc(uptr size); 52void InternalFree(void *p); 53// Given the pointer p into a valid allocated block, 54// returns a pointer to the beginning of the block. 55void *InternalAllocBlock(void *p); 56 57// InternalScopedBuffer can be used instead of large stack arrays to 58// keep frame size low. 59// FIXME: use InternalAlloc instead of MmapOrDie once 60// InternalAlloc is made libc-free. 61template<typename T> 62class InternalScopedBuffer { 63 public: 64 explicit InternalScopedBuffer(uptr cnt) { 65 cnt_ = cnt; 66 ptr_ = (T*)MmapOrDie(cnt * sizeof(T), "InternalScopedBuffer"); 67 } 68 ~InternalScopedBuffer() { 69 UnmapOrDie(ptr_, cnt_ * sizeof(T)); 70 } 71 T &operator[](uptr i) { return ptr_[i]; } 72 T *data() { return ptr_; } 73 uptr size() { return cnt_ * sizeof(T); } 74 75 private: 76 T *ptr_; 77 uptr cnt_; 78 // Disallow evil constructors. 79 InternalScopedBuffer(const InternalScopedBuffer&); 80 void operator=(const InternalScopedBuffer&); 81}; 82 83// Simple low-level (mmap-based) allocator for internal use. Doesn't have 84// constructor, so all instances of LowLevelAllocator should be 85// linker initialized. 86class LowLevelAllocator { 87 public: 88 // Requires an external lock. 89 void *Allocate(uptr size); 90 private: 91 char *allocated_end_; 92 char *allocated_current_; 93}; 94typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size); 95// Allows to register tool-specific callbacks for LowLevelAllocator. 96// Passing NULL removes the callback. 97void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback); 98 99// IO 100void RawWrite(const char *buffer); 101void Printf(const char *format, ...); 102void Report(const char *format, ...); 103void SetPrintfAndReportCallback(void (*callback)(const char *)); 104 105// Opens the file 'file_name" and reads up to 'max_len' bytes. 106// The resulting buffer is mmaped and stored in '*buff'. 107// The size of the mmaped region is stored in '*buff_size', 108// Returns the number of read bytes or 0 if file can not be opened. 109uptr ReadFileToBuffer(const char *file_name, char **buff, 110 uptr *buff_size, uptr max_len); 111// Maps given file to virtual memory, and returns pointer to it 112// (or NULL if the mapping failes). Stores the size of mmaped region 113// in '*buff_size'. 114void *MapFileToMemory(const char *file_name, uptr *buff_size); 115 116// OS 117void DisableCoreDumper(); 118void DumpProcessMap(); 119const char *GetEnv(const char *name); 120const char *GetPwd(); 121void ReExec(); 122bool StackSizeIsUnlimited(); 123void SetStackSizeLimitInBytes(uptr limit); 124 125// Other 126void SleepForSeconds(int seconds); 127void SleepForMillis(int millis); 128int Atexit(void (*function)(void)); 129void SortArray(uptr *array, uptr size); 130 131// Exit 132void NORETURN Abort(); 133void NORETURN Exit(int exitcode); 134void NORETURN Die(); 135void NORETURN SANITIZER_INTERFACE_ATTRIBUTE 136CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2); 137 138// Specific tools may override behavior of "Die" and "CheckFailed" functions 139// to do tool-specific job. 140void SetDieCallback(void (*callback)(void)); 141typedef void (*CheckFailedCallbackType)(const char *, int, const char *, 142 u64, u64); 143void SetCheckFailedCallback(CheckFailedCallbackType callback); 144 145// Math 146INLINE bool IsPowerOfTwo(uptr x) { 147 return (x & (x - 1)) == 0; 148} 149INLINE uptr RoundUpTo(uptr size, uptr boundary) { 150 CHECK(IsPowerOfTwo(boundary)); 151 return (size + boundary - 1) & ~(boundary - 1); 152} 153// Don't use std::min, std::max or std::swap, to minimize dependency 154// on libstdc++. 155template<class T> T Min(T a, T b) { return a < b ? a : b; } 156template<class T> T Max(T a, T b) { return a > b ? a : b; } 157template<class T> void Swap(T& a, T& b) { 158 T tmp = a; 159 a = b; 160 b = tmp; 161} 162 163// Char handling 164INLINE bool IsSpace(int c) { 165 return (c == ' ') || (c == '\n') || (c == '\t') || 166 (c == '\f') || (c == '\r') || (c == '\v'); 167} 168INLINE bool IsDigit(int c) { 169 return (c >= '0') && (c <= '9'); 170} 171INLINE int ToLower(int c) { 172 return (c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c; 173} 174 175#if __WORDSIZE == 64 176# define FIRST_32_SECOND_64(a, b) (b) 177#else 178# define FIRST_32_SECOND_64(a, b) (a) 179#endif 180 181} // namespace __sanitizer 182 183#endif // SANITIZER_COMMON_H 184