[tsan] Remove stdlib.h from dd_interceptors.cpp

[vitalybuka]

Summary

This fixes "realpath already defined" error.

[eugenis]

LGTM

compiler-rt/lib/tsan/dd/dd_interceptors.cpp

 //===-- dd_interceptors.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <pthread.h>
+
 #include "dd_rtl.h"
 #include "interception/interception.h"
+#include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
-#include <pthread.h>
-#include <stdlib.h>
 
 using namespace __dsan;
 
 __attribute__((tls_model("initial-exec")))
 static __thread Thread *thr;
 __attribute__((tls_model("initial-exec")))
 static __thread volatile int initing;
 static bool inited;
INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) {
   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));
+  void *newcond = InternalAlloc(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);
+  InternalFree(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_broadcast, pthread_cond_t *c) {
   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);
+  InternalFree(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);