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