sanitizer_common.h revision 1dc4cf7e253aefa3ce3bd4a1d349a13647e8b2ea 
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 GetThreadSelf();
38void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
39                                uptr *stack_bottom);
40
41// Memory management
42void *MmapOrDie(uptr size, const char *mem_type);
43void UnmapOrDie(void *addr, uptr size);
44void *MmapFixedNoReserve(uptr fixed_addr, uptr size);
45void *Mprotect(uptr fixed_addr, uptr size);
46// Used to check if we can map shadow memory to a fixed location.
47bool MemoryRangeIsAvailable(uptr range_start, uptr range_end);
48
49// Internal allocator
50void *InternalAlloc(uptr size);
51void InternalFree(void *p);
52// Given the pointer p into a valid allocated block,
53// returns a pointer to the beginning of the block.
54void *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.
60template<typename T>
61class 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.
85class LowLevelAllocator {
86 public:
87  // Requires an external lock.
88  void *Allocate(uptr size);
89 private:
90  char *allocated_end_;
91  char *allocated_current_;
92};
93typedef void (*LowLevelAllocateCallback)(uptr ptr, uptr size);
94// Allows to register tool-specific callbacks for LowLevelAllocator.
95// Passing NULL removes the callback.
96void SetLowLevelAllocateCallback(LowLevelAllocateCallback callback);
97
98// IO
99void RawWrite(const char *buffer);
100void Printf(const char *format, ...);
101void Report(const char *format, ...);
102void 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.
108uptr 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'.
113void *MapFileToMemory(const char *file_name, uptr *buff_size);
114
115const char *GetEnv(const char *name);
116const char *GetPwd();
117
118// Other
119void DisableCoreDumper();
120void DumpProcessMap();
121void SleepForSeconds(int seconds);
122void SleepForMillis(int millis);
123void NORETURN Exit(int exitcode);
124void NORETURN Abort();
125int Atexit(void (*function)(void));
126void SortArray(uptr *array, uptr size);
127
128// Math
129INLINE bool IsPowerOfTwo(uptr x) {
130  return (x & (x - 1)) == 0;
131}
132INLINE 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++.
138template<class T> T Min(T a, T b) { return a < b ? a : b; }
139template<class T> T Max(T a, T b) { return a > b ? a : b; }
140template<class T> void Swap(T& a, T& b) {
141  T tmp = a;
142  a = b;
143  b = tmp;
144}
145
146// Char handling
147INLINE bool IsSpace(int c) {
148  return (c == ' ') || (c == '\n') || (c == '\t') ||
149         (c == '\f') || (c == '\r') || (c == '\v');
150}
151INLINE bool IsDigit(int c) {
152  return (c >= '0') && (c <= '9');
153}
154INLINE 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