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