[rustc.git] / src / compiler-rt / lib / tsan / dd / dd_interceptors.cc

//===-- dd_interceptors.cc ------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "dd_rtl.h"
#include "interception/interception.h"
#include "sanitizer_common/sanitizer_procmaps.h"
#include <pthread.h>
#include <stdlib.h>

using namespace __dsan;

extern "C" void *__libc_malloc(uptr size);
extern "C" void __libc_free(void *ptr);

__attribute__((tls_model("initial-exec")))
static __thread Thread *thr;
__attribute__((tls_model("initial-exec")))
static __thread volatile int initing;
static bool inited;
static uptr g_data_start;
static uptr g_data_end;

static bool InitThread() {
  if (initing)
    return false;
  if (thr != 0)
    return true;
  initing = true;
  if (!inited) {
    inited = true;
    Initialize();
  }
  thr = (Thread*)InternalAlloc(sizeof(*thr));
  internal_memset(thr, 0, sizeof(*thr));
  ThreadInit(thr);
  initing = false;
  return true;
}

INTERCEPTOR(int, pthread_mutex_destroy, pthread_mutex_t *m) {
  InitThread();
  MutexDestroy(thr, (uptr)m);
  return REAL(pthread_mutex_destroy)(m);
}

INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *m) {
  InitThread();
  MutexBeforeLock(thr, (uptr)m, true);
  int res = REAL(pthread_mutex_lock)(m);
  MutexAfterLock(thr, (uptr)m, true, false);
  return res;
}

INTERCEPTOR(int, pthread_mutex_trylock, pthread_mutex_t *m) {
  InitThread();
  int res = REAL(pthread_mutex_trylock)(m);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, true, true);
  return res;
}

INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *m) {
  InitThread();
  MutexBeforeUnlock(thr, (uptr)m, true);
  return REAL(pthread_mutex_unlock)(m);
}

INTERCEPTOR(int, pthread_spin_destroy, pthread_spinlock_t *m) {
  InitThread();
  int res = REAL(pthread_spin_destroy)(m);
  MutexDestroy(thr, (uptr)m);
  return res;
}

INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *m) {
  InitThread();
  MutexBeforeLock(thr, (uptr)m, true);
  int res = REAL(pthread_spin_lock)(m);
  MutexAfterLock(thr, (uptr)m, true, false);
  return res;
}

INTERCEPTOR(int, pthread_spin_trylock, pthread_spinlock_t *m) {
  InitThread();
  int res = REAL(pthread_spin_trylock)(m);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, true, true);
  return res;
}

INTERCEPTOR(int, pthread_spin_unlock, pthread_spinlock_t *m) {
  InitThread();
  MutexBeforeUnlock(thr, (uptr)m, true);
  return REAL(pthread_spin_unlock)(m);
}

INTERCEPTOR(int, pthread_rwlock_destroy, pthread_rwlock_t *m) {
  InitThread();
  MutexDestroy(thr, (uptr)m);
  return REAL(pthread_rwlock_destroy)(m);
}

INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *m) {
  InitThread();
  MutexBeforeLock(thr, (uptr)m, false);
  int res = REAL(pthread_rwlock_rdlock)(m);
  MutexAfterLock(thr, (uptr)m, false, false);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_tryrdlock, pthread_rwlock_t *m) {
  InitThread();
  int res = REAL(pthread_rwlock_tryrdlock)(m);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, false, true);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_timedrdlock, pthread_rwlock_t *m,
    const timespec *abstime) {
  InitThread();
  int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, false, true);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *m) {
  InitThread();
  MutexBeforeLock(thr, (uptr)m, true);
  int res = REAL(pthread_rwlock_wrlock)(m);
  MutexAfterLock(thr, (uptr)m, true, false);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_trywrlock, pthread_rwlock_t *m) {
  InitThread();
  int res = REAL(pthread_rwlock_trywrlock)(m);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, true, true);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_timedwrlock, pthread_rwlock_t *m,
    const timespec *abstime) {
  InitThread();
  int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
  if (res == 0)
    MutexAfterLock(thr, (uptr)m, true, true);
  return res;
}

INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) {
  InitThread();
  MutexBeforeUnlock(thr, (uptr)m, true);  // note: not necessary write unlock
  return REAL(pthread_rwlock_unlock)(m);
}

static pthread_cond_t *init_cond(pthread_cond_t *c, bool force = false) {
  atomic_uintptr_t *p = (atomic_uintptr_t*)c;
  uptr cond = atomic_load(p, memory_order_acquire);
  if (!force && cond != 0)
    return (pthread_cond_t*)cond;
  void *newcond = malloc(sizeof(pthread_cond_t));
  internal_memset(newcond, 0, sizeof(pthread_cond_t));
  if (atomic_compare_exchange_strong(p, &cond, (uptr)newcond,
      memory_order_acq_rel))
    return (pthread_cond_t*)newcond;
  free(newcond);
  return (pthread_cond_t*)cond;
}

INTERCEPTOR(int, pthread_cond_init, pthread_cond_t *c,
    const pthread_condattr_t *a) {
  InitThread();
  pthread_cond_t *cond = init_cond(c, true);
  return REAL(pthread_cond_init)(cond, a);
}

INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *c, pthread_mutex_t *m) {
  InitThread();
  pthread_cond_t *cond = init_cond(c);
  MutexBeforeUnlock(thr, (uptr)m, true);
  MutexBeforeLock(thr, (uptr)m, true);
  int res = REAL(pthread_cond_wait)(cond, m);
  MutexAfterLock(thr, (uptr)m, true, false);
  return res;
}

INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m,
    const timespec *abstime) {
  InitThread();
  pthread_cond_t *cond = init_cond(c);
  MutexBeforeUnlock(thr, (uptr)m, true);
  MutexBeforeLock(thr, (uptr)m, true);
  int res = REAL(pthread_cond_timedwait)(cond, m, abstime);
  MutexAfterLock(thr, (uptr)m, true, false);
  return res;
}

INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *c) {
  InitThread();
  pthread_cond_t *cond = init_cond(c);
  return REAL(pthread_cond_signal)(cond);
}

INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *c) {
  InitThread();
  pthread_cond_t *cond = init_cond(c);
  return REAL(pthread_cond_broadcast)(cond);
}

INTERCEPTOR(int, pthread_cond_destroy, pthread_cond_t *c) {
  InitThread();
  pthread_cond_t *cond = init_cond(c);
  int res = REAL(pthread_cond_destroy)(cond);
  free(cond);
  atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
  return res;
}

// for symbolizer
INTERCEPTOR(char*, realpath, const char *path, char *resolved_path) {
  InitThread();
  return REAL(realpath)(path, resolved_path);
}

INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
  InitThread();
  return REAL(read)(fd, ptr, count);
}

INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
  InitThread();
  return REAL(pread)(fd, ptr, count, offset);
}

extern "C" {
void __dsan_before_mutex_lock(uptr m, int writelock) {
  if (!InitThread())
    return;
  MutexBeforeLock(thr, m, writelock);
}

void __dsan_after_mutex_lock(uptr m, int writelock, int trylock) {
  if (!InitThread())
    return;
  MutexAfterLock(thr, m, writelock, trylock);
}

void __dsan_before_mutex_unlock(uptr m, int writelock) {
  if (!InitThread())
    return;
  MutexBeforeUnlock(thr, m, writelock);
}

void __dsan_mutex_destroy(uptr m) {
  if (!InitThread())
    return;
  // if (m >= g_data_start && m < g_data_end)
  //   return;
  MutexDestroy(thr, m);
}
}  // extern "C"

namespace __dsan {

static void InitDataSeg() {
  MemoryMappingLayout proc_maps(true);
  uptr start, end, offset;
  char name[128];
  bool prev_is_data = false;
  while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name),
                        /*protection*/ 0)) {
    bool is_data = offset != 0 && name[0] != 0;
    // BSS may get merged with [heap] in /proc/self/maps. This is not very
    // reliable.
    bool is_bss = offset == 0 &&
      (name[0] == 0 || internal_strcmp(name, "[heap]") == 0) && prev_is_data;
    if (g_data_start == 0 && is_data)
      g_data_start = start;
    if (is_bss)
      g_data_end = end;
    prev_is_data = is_data;
  }
  VPrintf(1, "guessed data_start=%p data_end=%p\n",  g_data_start, g_data_end);
  CHECK_LT(g_data_start, g_data_end);
  CHECK_GE((uptr)&g_data_start, g_data_start);
  CHECK_LT((uptr)&g_data_start, g_data_end);
}

void InitializeInterceptors() {
  INTERCEPT_FUNCTION(pthread_mutex_destroy);
  INTERCEPT_FUNCTION(pthread_mutex_lock);
  INTERCEPT_FUNCTION(pthread_mutex_trylock);
  INTERCEPT_FUNCTION(pthread_mutex_unlock);

  INTERCEPT_FUNCTION(pthread_spin_destroy);
  INTERCEPT_FUNCTION(pthread_spin_lock);
  INTERCEPT_FUNCTION(pthread_spin_trylock);
  INTERCEPT_FUNCTION(pthread_spin_unlock);

  INTERCEPT_FUNCTION(pthread_rwlock_destroy);
  INTERCEPT_FUNCTION(pthread_rwlock_rdlock);
  INTERCEPT_FUNCTION(pthread_rwlock_tryrdlock);
  INTERCEPT_FUNCTION(pthread_rwlock_timedrdlock);
  INTERCEPT_FUNCTION(pthread_rwlock_wrlock);
  INTERCEPT_FUNCTION(pthread_rwlock_trywrlock);
  INTERCEPT_FUNCTION(pthread_rwlock_timedwrlock);
  INTERCEPT_FUNCTION(pthread_rwlock_unlock);

  INTERCEPT_FUNCTION_VER(pthread_cond_init, "GLIBC_2.3.2");
  INTERCEPT_FUNCTION_VER(pthread_cond_signal, "GLIBC_2.3.2");
  INTERCEPT_FUNCTION_VER(pthread_cond_broadcast, "GLIBC_2.3.2");
  INTERCEPT_FUNCTION_VER(pthread_cond_wait, "GLIBC_2.3.2");
  INTERCEPT_FUNCTION_VER(pthread_cond_timedwait, "GLIBC_2.3.2");
  INTERCEPT_FUNCTION_VER(pthread_cond_destroy, "GLIBC_2.3.2");

  // for symbolizer
  INTERCEPT_FUNCTION(realpath);
  INTERCEPT_FUNCTION(read);
  INTERCEPT_FUNCTION(pread);

  InitDataSeg();
}

}  // namespace __dsan
Commit	Line	Data
1a4d82fc JJ	1	//===-- dd_interceptors.cc ------------------------------------------------===//
	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	#include "dd_rtl.h"
	11	#include "interception/interception.h"
	12	#include "sanitizer_common/sanitizer_procmaps.h"
	13	#include <pthread.h>
	14	#include <stdlib.h>
	15
	16	using namespace __dsan;
	17
	18	extern "C" void *__libc_malloc(uptr size);
	19	extern "C" void __libc_free(void *ptr);
	20
	21	__attribute__((tls_model("initial-exec")))
	22	static __thread Thread *thr;
	23	__attribute__((tls_model("initial-exec")))
	24	static __thread volatile int initing;
	25	static bool inited;
	26	static uptr g_data_start;
	27	static uptr g_data_end;
	28
	29	static bool InitThread() {
	30	if (initing)
	31	return false;
	32	if (thr != 0)
	33	return true;
	34	initing = true;
	35	if (!inited) {
	36	inited = true;
	37	Initialize();
	38	}
	39	thr = (Thread)InternalAlloc(sizeof(thr));
	40	internal_memset(thr, 0, sizeof(*thr));
	41	ThreadInit(thr);
	42	initing = false;
	43	return true;
	44	}
	45
	46	INTERCEPTOR(int, pthread_mutex_destroy, pthread_mutex_t *m) {
	47	InitThread();
	48	MutexDestroy(thr, (uptr)m);
	49	return REAL(pthread_mutex_destroy)(m);
	50	}
	51
	52	INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *m) {
	53	InitThread();
	54	MutexBeforeLock(thr, (uptr)m, true);
	55	int res = REAL(pthread_mutex_lock)(m);
	56	MutexAfterLock(thr, (uptr)m, true, false);
	57	return res;
	58	}
	59
	60	INTERCEPTOR(int, pthread_mutex_trylock, pthread_mutex_t *m) {
	61	InitThread();
	62	int res = REAL(pthread_mutex_trylock)(m);
	63	if (res == 0)
	64	MutexAfterLock(thr, (uptr)m, true, true);
65	return res;
66	}
67
68	INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *m) {
69	InitThread();
70	MutexBeforeUnlock(thr, (uptr)m, true);
71	return REAL(pthread_mutex_unlock)(m);
72	}
73
74	INTERCEPTOR(int, pthread_spin_destroy, pthread_spinlock_t *m) {
75	InitThread();
76	int res = REAL(pthread_spin_destroy)(m);
77	MutexDestroy(thr, (uptr)m);
78	return res;
79	}
80
81	INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *m) {
82	InitThread();
83	MutexBeforeLock(thr, (uptr)m, true);
84	int res = REAL(pthread_spin_lock)(m);
85	MutexAfterLock(thr, (uptr)m, true, false);
86	return res;
87	}
88
89	INTERCEPTOR(int, pthread_spin_trylock, pthread_spinlock_t *m) {
90	InitThread();
91	int res = REAL(pthread_spin_trylock)(m);
92	if (res == 0)
93	MutexAfterLock(thr, (uptr)m, true, true);
94	return res;
95	}
96
97	INTERCEPTOR(int, pthread_spin_unlock, pthread_spinlock_t *m) {
98	InitThread();
99	MutexBeforeUnlock(thr, (uptr)m, true);
100	return REAL(pthread_spin_unlock)(m);
101	}
102
103	INTERCEPTOR(int, pthread_rwlock_destroy, pthread_rwlock_t *m) {
104	InitThread();
105	MutexDestroy(thr, (uptr)m);
106	return REAL(pthread_rwlock_destroy)(m);
107	}
108
109	INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *m) {
110	InitThread();
111	MutexBeforeLock(thr, (uptr)m, false);
112	int res = REAL(pthread_rwlock_rdlock)(m);
113	MutexAfterLock(thr, (uptr)m, false, false);
114	return res;
115	}
116
117	INTERCEPTOR(int, pthread_rwlock_tryrdlock, pthread_rwlock_t *m) {
118	InitThread();
119	int res = REAL(pthread_rwlock_tryrdlock)(m);
120	if (res == 0)
121	MutexAfterLock(thr, (uptr)m, false, true);
122	return res;
123	}
124
125	INTERCEPTOR(int, pthread_rwlock_timedrdlock, pthread_rwlock_t *m,
126	const timespec *abstime) {
127	InitThread();
128	int res = REAL(pthread_rwlock_timedrdlock)(m, abstime);
129	if (res == 0)
130	MutexAfterLock(thr, (uptr)m, false, true);
131	return res;
132	}
133
134	INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *m) {
135	InitThread();
136	MutexBeforeLock(thr, (uptr)m, true);
137	int res = REAL(pthread_rwlock_wrlock)(m);
138	MutexAfterLock(thr, (uptr)m, true, false);
139	return res;
140	}
141
142	INTERCEPTOR(int, pthread_rwlock_trywrlock, pthread_rwlock_t *m) {
143	InitThread();
144	int res = REAL(pthread_rwlock_trywrlock)(m);
145	if (res == 0)
146	MutexAfterLock(thr, (uptr)m, true, true);
147	return res;
148	}
149
150	INTERCEPTOR(int, pthread_rwlock_timedwrlock, pthread_rwlock_t *m,
151	const timespec *abstime) {
152	InitThread();
153	int res = REAL(pthread_rwlock_timedwrlock)(m, abstime);
154	if (res == 0)
155	MutexAfterLock(thr, (uptr)m, true, true);
156	return res;
157	}
158
159	INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) {
160	InitThread();
161	MutexBeforeUnlock(thr, (uptr)m, true); // note: not necessary write unlock
162	return REAL(pthread_rwlock_unlock)(m);
163	}
164
165	static pthread_cond_t init_cond(pthread_cond_t c, bool force = false) {
166	atomic_uintptr_t p = (atomic_uintptr_t)c;
167	uptr cond = atomic_load(p, memory_order_acquire);
168	if (!force && cond != 0)
169	return (pthread_cond_t*)cond;
170	void *newcond = malloc(sizeof(pthread_cond_t));
171	internal_memset(newcond, 0, sizeof(pthread_cond_t));
172	if (atomic_compare_exchange_strong(p, &cond, (uptr)newcond,
173	memory_order_acq_rel))
174	return (pthread_cond_t*)newcond;
175	free(newcond);
176	return (pthread_cond_t*)cond;
177	}
178
179	INTERCEPTOR(int, pthread_cond_init, pthread_cond_t *c,
180	const pthread_condattr_t *a) {
181	InitThread();
182	pthread_cond_t *cond = init_cond(c, true);
183	return REAL(pthread_cond_init)(cond, a);
184	}
185
186	INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t c, pthread_mutex_t m) {
187	InitThread();
188	pthread_cond_t *cond = init_cond(c);
189	MutexBeforeUnlock(thr, (uptr)m, true);
190	MutexBeforeLock(thr, (uptr)m, true);
191	int res = REAL(pthread_cond_wait)(cond, m);
192	MutexAfterLock(thr, (uptr)m, true, false);
193	return res;
194	}
195
196	INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t c, pthread_mutex_t m,
197	const timespec *abstime) {
198	InitThread();
199	pthread_cond_t *cond = init_cond(c);
200	MutexBeforeUnlock(thr, (uptr)m, true);
201	MutexBeforeLock(thr, (uptr)m, true);
202	int res = REAL(pthread_cond_timedwait)(cond, m, abstime);
203	MutexAfterLock(thr, (uptr)m, true, false);
204	return res;
205	}
206
207	INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *c) {
208	InitThread();
209	pthread_cond_t *cond = init_cond(c);
210	return REAL(pthread_cond_signal)(cond);
211	}
212
213	INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *c) {
214	InitThread();
215	pthread_cond_t *cond = init_cond(c);
216	return REAL(pthread_cond_broadcast)(cond);
217	}
218
219	INTERCEPTOR(int, pthread_cond_destroy, pthread_cond_t *c) {
220	InitThread();
221	pthread_cond_t *cond = init_cond(c);
222	int res = REAL(pthread_cond_destroy)(cond);
223	free(cond);
224	atomic_store((atomic_uintptr_t*)c, 0, memory_order_relaxed);
225	return res;
226	}
227
228	// for symbolizer
229	INTERCEPTOR(char, realpath, const char path, char *resolved_path) {
230	InitThread();
231	return REAL(realpath)(path, resolved_path);
232	}
233
234	INTERCEPTOR(SSIZE_T, read, int fd, void *ptr, SIZE_T count) {
235	InitThread();
236	return REAL(read)(fd, ptr, count);
237	}
238
239	INTERCEPTOR(SSIZE_T, pread, int fd, void *ptr, SIZE_T count, OFF_T offset) {
240	InitThread();
241	return REAL(pread)(fd, ptr, count, offset);
242	}
243
244	extern "C" {
245	void __dsan_before_mutex_lock(uptr m, int writelock) {
246	if (!InitThread())
247	return;
248	MutexBeforeLock(thr, m, writelock);
249	}
250
251	void __dsan_after_mutex_lock(uptr m, int writelock, int trylock) {
252	if (!InitThread())
253	return;
254	MutexAfterLock(thr, m, writelock, trylock);
255	}
256
257	void __dsan_before_mutex_unlock(uptr m, int writelock) {
258	if (!InitThread())
259	return;
260	MutexBeforeUnlock(thr, m, writelock);
261	}
262
263	void __dsan_mutex_destroy(uptr m) {
264	if (!InitThread())
265	return;
266	// if (m >= g_data_start && m < g_data_end)
267	// return;
268	MutexDestroy(thr, m);
269	}
270	} // extern "C"
271
272	namespace __dsan {
273
274	static void InitDataSeg() {
275	MemoryMappingLayout proc_maps(true);
276	uptr start, end, offset;
277	char name[128];
278	bool prev_is_data = false;
279	while (proc_maps.Next(&start, &end, &offset, name, ARRAY_SIZE(name),
280	/protection/ 0)) {
281	bool is_data = offset != 0 && name[0] != 0;
282	// BSS may get merged with [heap] in /proc/self/maps. This is not very
283	// reliable.
284	bool is_bss = offset == 0 &&
285	(name[0] == 0 \|\| internal_strcmp(name, "[heap]") == 0) && prev_is_data;
286	if (g_data_start == 0 && is_data)
287	g_data_start = start;
288	if (is_bss)
289	g_data_end = end;
290	prev_is_data = is_data;
291	}
292	VPrintf(1, "guessed data_start=%p data_end=%p\n", g_data_start, g_data_end);
293	CHECK_LT(g_data_start, g_data_end);
294	CHECK_GE((uptr)&g_data_start, g_data_start);
295	CHECK_LT((uptr)&g_data_start, g_data_end);
296	}
297
298	void InitializeInterceptors() {
299	INTERCEPT_FUNCTION(pthread_mutex_destroy);
300	INTERCEPT_FUNCTION(pthread_mutex_lock);
301	INTERCEPT_FUNCTION(pthread_mutex_trylock);
302	INTERCEPT_FUNCTION(pthread_mutex_unlock);
303
304	INTERCEPT_FUNCTION(pthread_spin_destroy);
305	INTERCEPT_FUNCTION(pthread_spin_lock);
306	INTERCEPT_FUNCTION(pthread_spin_trylock);
307	INTERCEPT_FUNCTION(pthread_spin_unlock);
308
309	INTERCEPT_FUNCTION(pthread_rwlock_destroy);
310	INTERCEPT_FUNCTION(pthread_rwlock_rdlock);
311	INTERCEPT_FUNCTION(pthread_rwlock_tryrdlock);
312	INTERCEPT_FUNCTION(pthread_rwlock_timedrdlock);
313	INTERCEPT_FUNCTION(pthread_rwlock_wrlock);
314	INTERCEPT_FUNCTION(pthread_rwlock_trywrlock);
315	INTERCEPT_FUNCTION(pthread_rwlock_timedwrlock);
316	INTERCEPT_FUNCTION(pthread_rwlock_unlock);
317
318	INTERCEPT_FUNCTION_VER(pthread_cond_init, "GLIBC_2.3.2");
319	INTERCEPT_FUNCTION_VER(pthread_cond_signal, "GLIBC_2.3.2");
320	INTERCEPT_FUNCTION_VER(pthread_cond_broadcast, "GLIBC_2.3.2");
321	INTERCEPT_FUNCTION_VER(pthread_cond_wait, "GLIBC_2.3.2");
322	INTERCEPT_FUNCTION_VER(pthread_cond_timedwait, "GLIBC_2.3.2");
323	INTERCEPT_FUNCTION_VER(pthread_cond_destroy, "GLIBC_2.3.2");
324
325	// for symbolizer
326	INTERCEPT_FUNCTION(realpath);
327	INTERCEPT_FUNCTION(read);
328	INTERCEPT_FUNCTION(pread);
329
330	InitDataSeg();
331	}
332
333	} // namespace __dsan