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