sanitizer_common.h revision 14c8bd7250742749e44e306c02a56cf47ad1db82 
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.
58template<typename T>
59class InternalScopedBuffer {
60 public:
61  explicit InternalScopedBuffer(uptr cnt) {
62    cnt_ = cnt;
63    ptr_ = (T*)InternalAlloc(cnt * sizeof(T));
64  }
65  ~InternalScopedBuffer() {
66    InternalFree(ptr_);
67  }
68  operator T*() { return ptr_; }
69  T &operator[](uptr i) { return ptr_[i]; }
70  T *data() { return ptr_; }
71  uptr size() { return cnt_ * sizeof(T); }
72
73 private:
74  T *ptr_;
75  uptr cnt_;
76  // Disallow evil constructors.
77  InternalScopedBuffer(const InternalScopedBuffer&);
78  void operator=(const InternalScopedBuffer&);
79};
80
81// IO
82void RawWrite(const char *buffer);
83void Printf(const char *format, ...);
84void Report(const char *format, ...);
85
86// Opens the file 'file_name" and reads up to 'max_len' bytes.
87// The resulting buffer is mmaped and stored in '*buff'.
88// The size of the mmaped region is stored in '*buff_size',
89// Returns the number of read bytes or 0 if file can not be opened.
90uptr ReadFileToBuffer(const char *file_name, char **buff,
91                      uptr *buff_size, uptr max_len);
92// Maps given file to virtual memory, and returns pointer to it
93// (or NULL if the mapping failes). Stores the size of mmaped region
94// in '*buff_size'.
95void *MapFileToMemory(const char *file_name, uptr *buff_size);
96
97const char *GetEnv(const char *name);
98const char *GetPwd();
99
100// Other
101void DisableCoreDumper();
102void DumpProcessMap();
103void SleepForSeconds(int seconds);
104void SleepForMillis(int millis);
105void NORETURN Exit(int exitcode);
106void NORETURN Abort();
107int Atexit(void (*function)(void));
108void SortArray(uptr *array, uptr size);
109
110// Math
111INLINE bool IsPowerOfTwo(uptr x) {
112  return (x & (x - 1)) == 0;
113}
114INLINE uptr RoundUpTo(uptr size, uptr boundary) {
115  CHECK(IsPowerOfTwo(boundary));
116  return (size + boundary - 1) & ~(boundary - 1);
117}
118// Don't use std::min, std::max or std::swap, to minimize dependency
119// on libstdc++.
120template<class T> T Min(T a, T b) { return a < b ? a : b; }
121template<class T> T Max(T a, T b) { return a > b ? a : b; }
122template<class T> void Swap(T& a, T& b) {
123  T tmp = a;
124  a = b;
125  b = tmp;
126}
127
128// Char handling
129INLINE bool IsSpace(int c) {
130  return (c == ' ') || (c == '\n') || (c == '\t') ||
131         (c == '\f') || (c == '\r') || (c == '\v');
132}
133INLINE bool IsDigit(int c) {
134  return (c >= '0') && (c <= '9');
135}
136INLINE int ToLower(int c) {
137  return (c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c;
138}
139
140#if __WORDSIZE == 64
141# define FIRST_32_SECOND_64(a, b) (b)
142#else
143# define FIRST_32_SECOND_64(a, b) (a)
144#endif
145
146}  // namespace __sanitizer
147
148#endif  // SANITIZER_COMMON_H
149