tsan: introduce New/Alloc/Free helpers

[dvyukov]

Summary

We frequenty allocate sizeof(T) memory and call T ctor on that memory
(C++ new keyword effectively). Currently it's quite verbose and
usually takes 2 lines of code.
Add New<T>() helper that does it much more concisely.

Rename internal_free to Free that also sets the pointer to nullptr.
Shorter and safer.

Rename internal_alloc to Alloc, just shorter.

[vitalybuka]

compiler-rt/lib/tsan/rtl/tsan_mman.h

71

if (p == nullptr) is needed here or caller will have to check
and it will make it more similar to delete operator.

compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp

309

Can you make clang-tidy happy?

[melver]

compiler-rt/lib/tsan/rtl/tsan_mman.h

55–70

You could make New also forward arguments:

template <typename T, typename... U>
T *New(U&&... u) {
  return new (Alloc(sizeof(T))) T(std::forward<U>(u)...));
}

Then in other locations where you're still doing placement new + alloc you could also just use New<Foo>(args,..)

[dvyukov]

addressed comments

[melver]

compiler-rt/lib/tsan/rtl/tsan_mman.h

55–70

https://reviews.llvm.org/D107147

[dvyukov]

compiler-rt/lib/tsan/rtl/tsan_mman.h

55–70

It would be nice, but I am not sure we can use C++ library in general, and newer features with older host compilers (like the ones we have on some buildbots). We have own declaration of placement new, I dunno if it's needed but FWIW.
So if we try this, I would prefer to not mix with this change.

[hctim]

Looks like this broke the bots: https://lab.llvm.org/buildbot/#/builders/70/builds/10083

[hctim]

FAIL: ThreadSanitizer-x86_64 :: benign_race.cpp (148 of 419)
******************** TEST 'ThreadSanitizer-x86_64 :: benign_race.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';      /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/./bin/clang  -fsanitize=thread -Wall  -m64   -gline-tables-only -I/b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/../ -O1 /b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/benign_race.cpp -o /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/tools/clang/runtime/compiler-rt-bins/test/tsan/X86_64Config/Output/benign_race.cpp.tmp &&  /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/tools/clang/runtime/compiler-rt-bins/test/tsan/X86_64Config/Output/benign_race.cpp.tmp 2>&1 | FileCheck /b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/benign_race.cpp
--
Exit Code: 66
********************
Testing:  0.. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. 
********************
Failed Tests (1):
  ThreadSanitizer-x86_64 :: benign_race.cpp

[dvyukov]

In D107085#2916709, @hctim wrote:

FAIL: ThreadSanitizer-x86_64 :: benign_race.cpp (148 of 419)
******************** TEST 'ThreadSanitizer-x86_64 :: benign_race.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';      /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/./bin/clang  -fsanitize=thread -Wall  -m64   -gline-tables-only -I/b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/../ -O1 /b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/benign_race.cpp -o /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/tools/clang/runtime/compiler-rt-bins/test/tsan/X86_64Config/Output/benign_race.cpp.tmp &&  /b/sanitizer-x86_64-linux-autoconf/build/tsan_debug_build/tools/clang/runtime/compiler-rt-bins/test/tsan/X86_64Config/Output/benign_race.cpp.tmp 2>&1 | FileCheck /b/sanitizer-x86_64-linux-autoconf/build/llvm-project/compiler-rt/test/tsan/benign_race.cpp
--
Exit Code: 66
********************
Testing:  0.. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. 
********************
Failed Tests (1):
  ThreadSanitizer-x86_64 :: benign_race.cpp

I am puzzled why this single bot failed on this single test... The change indeed touches tsan_interface_ann.cpp which is involved in benign race handling, but I don't see how this change is not a no-op...

[vitalybuka]

This comment was removed by vitalybuka.

[dvyukov]

I've tried with SANITIZER_DEBUG=0/1 with clang/gcc, still can't reproduce.
Pity our bots still don't print test output... Is it data race or CHECK failure?...

[dvyukov]

I've stared at this change more, but don't see anything that could have caused the failure. I am out of ideas now.
We could try:

• race = New<ExpectRace>(); + race = Alloc(sizeof(ExpectRace));

but I don't see why it would help.

[melver]

In D107085#2916978, @dvyukov wrote:

I've stared at this change more, but don't see anything that could have caused the failure. I am out of ideas now.
We could try:

• race = New<ExpectRace>(); + race = Alloc(sizeof(ExpectRace));

but I don't see why it would help.

I can repro with the steps at https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild --

BUILDBOT_MONO_REPO_PATH=$(cd ../llvm-project && pwd) BUILDBOT_CLOBBER= BUILDBOT_REVISION= ./llvm-zorg/zorg/buildbot/builders/sanitizers/buildbot_standard.sh

Running that test only without piping into FileCheck I see:

ThreadSanitizer: CHECK failed: sanitizer_mutex.cpp:198 "((locked[i].recursion)) == ((0))" (0x1, 0x0) (tid=3329281)
    #0 __tsan::CheckUnwind() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_rtl.cpp:383:25 (benign_race.cpp.tmp+0x4e97b1)
    #1 __sanitizer::CheckFailed(char const*, int, char const*, unsigned long long, unsigned long long) /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_termination.cpp:86:5 (benign_race.cpp.tmp+0x43c673)
    #2 __sanitizer::InternalDeadlockDetector::CheckNoLocks() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_mutex.cpp:198:48 (benign_race.cpp.tmp+0x43433f)
    #3 __sanitizer::CheckedMutex::CheckNoLocksImpl() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_mutex.cpp:222:59 (benign_race.cpp.tmp+0x433c0b)
    #4 __sanitizer::CheckedMutex::CheckNoLocks() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/../sanitizer_common/sanitizer_mutex.h:137:5 (benign_race.cpp.tmp+0x4c5268)
    #5 __tsan::ScopedInterceptor::~ScopedInterceptor() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp:268:5 (benign_race.cpp.tmp+0x460712)
    #6 memset /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/../sanitizer_common/sanitizer_common_interceptors.inc:799:3 (benign_race.cpp.tmp+0x46d1c1)
    #7 __tsan::ExpectRace* __tsan::New<__tsan::ExpectRace>() /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_mman.h:56:33 (benign_race.cpp.tmp+0x4cae04)
    #8 __tsan::AddExpectRace(__tsan::ExpectRace*, char*, int, unsigned long, unsigned long, char*) /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp:92:10 (benign_race.cpp.tmp+0x4c9913)
    #9 BenignRaceImpl(char*, int, unsigned long, unsigned long, char*) /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp:355:3 (benign_race.cpp.tmp+0x4c9b00)
    #10 AnnotateBenignRaceSized /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp:364:3 (benign_race.cpp.tmp+0x4c9aa0)
    #11 main /usr/local/google/home/elver/third_party/llvm/llvm-project/compiler-rt/test/tsan/benign_race.cpp:16:3 (benign_race.cpp.tmp+0x51be4c)
    #12 __libc_start_main csu/../csu/libc-start.c:308:16 (libc.so.6+0x26d09)
    #13 _start <null> (benign_race.cpp.tmp+0x4212c9)

[dvyukov]

Ok, now it's obvious what happens. Thanks, Marco.
Something happened with out test for memset/memcpy in runtime. It should have been detected it with a clear explanation.
And I still don't understand why there is memset... the default ctor should not store anything into the object...
But anyway I mailed https://reviews.llvm.org/D107212 to revert back to Alloc.

compiler-rt/lib/tsan/go/tsan_go.cpp

 
 void InitializeDynamicAnnotations() {
 }
 
 bool IsExpectedReport(uptr addr, uptr size) {
   return false;
 }
 
-void *internal_alloc(uptr sz) { return InternalAlloc(sz); }
+void *Alloc(uptr sz) { return InternalAlloc(sz); }
 
-void internal_free(void *p) {
-  InternalFree(p);
-}
+void FreeImpl(void *p) { InternalFree(p); }
 
 // Callback into Go.
 static void (*go_runtime_cb)(uptr cmd, void *ctx);
 
 enum {
   CallbackGetProc = 0,
   CallbackSymbolizeCode = 1,
   CallbackSymbolizeData = 2,
ReportLocation *SymbolizeData(uptr addr) {
   cbctx.addr = addr;
   go_runtime_cb(CallbackSymbolizeData, &cbctx);
   if (!cbctx.res)
     return 0;
   if (cbctx.heap) {
     MBlock *b = ctx->metamap.GetBlock(cbctx.start);
     if (!b)
       return 0;
-    ReportLocation *loc = ReportLocation::New(ReportLocationHeap);
+    auto loc = New<ReportLocation>();
+    loc->type = ReportLocationHeap;
     loc->heap_chunk_start = cbctx.start;
     loc->heap_chunk_size = b->siz;
     loc->tid = b->tid;
     loc->stack = SymbolizeStackId(b->stk);
     return loc;
   } else {
-    ReportLocation *loc = ReportLocation::New(ReportLocationGlobal);
+    auto loc = New<ReportLocation>();
+    loc->type = ReportLocationGlobal;
     loc->global.name = internal_strdup(cbctx.name ? cbctx.name : "??");
     loc->global.file = internal_strdup(cbctx.file ? cbctx.file : "??");
     loc->global.line = cbctx.line;
     loc->global.start = cbctx.start;
     loc->global.size = cbctx.size;
     return loc;
   }
 }

 
 Processor *ThreadState::proc() {
   return get_cur_proc();
 }
 
 extern "C" {
 
 static ThreadState *AllocGoroutine() {
-  ThreadState *thr = (ThreadState *)internal_alloc(sizeof(ThreadState));
+  auto thr = (ThreadState *)Alloc(sizeof(ThreadState));
   internal_memset(thr, 0, sizeof(*thr));
   return thr;
 }
 
 void __tsan_init(ThreadState **thrp, Processor **procp,
                  void (*cb)(uptr cmd, void *cb)) {
   go_runtime_cb = cb;
   ThreadState *thr = AllocGoroutine();
void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
   ThreadState *thr = AllocGoroutine();
   *pthr = thr;
   int goid = ThreadCreate(parent, (uptr)pc, 0, true);
   ThreadStart(thr, goid, 0, ThreadType::Regular);
 }
 
 void __tsan_go_end(ThreadState *thr) {
   ThreadFinish(thr);
-  internal_free(thr);
+  Free(thr);
 }
 
 void __tsan_proc_create(Processor **pproc) {
   *pproc = ProcCreate();
 }
 
 void __tsan_proc_destroy(Processor *proc) {
   ProcDestroy(proc);

compiler-rt/lib/tsan/rtl/tsan_external.cpp

 void __tsan_external_register_header(void *tag, const char *header) {
   CHECK_GE((uptr)tag, kExternalTagFirstUserAvailable);
   CHECK_LT((uptr)tag, kExternalTagMax);
   atomic_uintptr_t *header_ptr =
       (atomic_uintptr_t *)&GetTagData((uptr)tag)->header;
   header = internal_strdup(header);
   char *old_header =
       (char *)atomic_exchange(header_ptr, (uptr)header, memory_order_seq_cst);
-  if (old_header) internal_free(old_header);
+  Free(old_header);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_external_assign_tag(void *addr, void *tag) {
   CHECK_LT(tag, atomic_load(&used_tags, memory_order_relaxed));
   Allocator *a = allocator();
   MBlock *b = nullptr;
   if (a->PointerIsMine((void *)addr)) {

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

AtExitCtx *ctx;
     // Pop AtExitCtx from the top of the stack of callback functions
     uptr element = interceptor_ctx()->AtExitStack.Size() - 1;
     ctx = interceptor_ctx()->AtExitStack[element];
     interceptor_ctx()->AtExitStack.PopBack();
   }
 
   Acquire(cur_thread(), (uptr)0, (uptr)ctx);
   ((void(*)())ctx->f)();
-  InternalFree(ctx);
+  Free(ctx);
 }
 
 static void cxa_at_exit_wrapper(void *arg) {
   Acquire(cur_thread(), 0, (uptr)arg);
   AtExitCtx *ctx = (AtExitCtx*)arg;
   ((void(*)(void *arg))ctx->f)(ctx->arg);
-  InternalFree(ctx);
+  Free(ctx);
 }
 
 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
       void *arg, void *dso);
 
 #if !SANITIZER_ANDROID
 TSAN_INTERCEPTOR(int, atexit, void (*f)()) {
   if (in_symbolizer())
TSAN_INTERCEPTOR(int, __cxa_atexit, void (*f)(void *a), void *arg, void *dso) {
   if (in_symbolizer())
     return 0;
   SCOPED_TSAN_INTERCEPTOR(__cxa_atexit, f, arg, dso);
   return setup_at_exit_wrapper(thr, pc, (void(*)())f, arg, dso);
 }
 
 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
       void *arg, void *dso) {
-  AtExitCtx *ctx = (AtExitCtx*)InternalAlloc(sizeof(AtExitCtx));
+  auto *ctx = New<AtExitCtx>();
   ctx->f = f;
   ctx->arg = arg;
   Release(thr, pc, (uptr)ctx);
   // Memory allocation in __cxa_atexit will race with free during exit,
   // because we do not see synchronization around atexit callback list.
   ThreadIgnoreBegin(thr, pc);
   int res;
   if (!dso) {

 
 #if !SANITIZER_MAC && !SANITIZER_NETBSD
 static void on_exit_wrapper(int status, void *arg) {
   ThreadState *thr = cur_thread();
   uptr pc = 0;
   Acquire(thr, pc, (uptr)arg);
   AtExitCtx *ctx = (AtExitCtx*)arg;
   ((void(*)(int status, void *arg))ctx->f)(status, ctx->arg);
-  InternalFree(ctx);
+  Free(ctx);
 }
 
 TSAN_INTERCEPTOR(int, on_exit, void(*f)(int, void*), void *arg) {
   if (in_symbolizer())
     return 0;
   SCOPED_TSAN_INTERCEPTOR(on_exit, f, arg);
-  AtExitCtx *ctx = (AtExitCtx*)InternalAlloc(sizeof(AtExitCtx));
+  auto *ctx = New<AtExitCtx>();
   ctx->f = (void(*)())f;
   ctx->arg = arg;
   Release(thr, pc, (uptr)ctx);
   // Memory allocation in __cxa_atexit will race with free during exit,
   // because we do not see synchronization around atexit callback list.
   ThreadIgnoreBegin(thr, pc);
   int res = REAL(on_exit)(on_exit_wrapper, ctx);
   ThreadIgnoreEnd(thr);

compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp

static void AddExpectRace(ExpectRace *list,
   ExpectRace *race = list->next;
   for (; race != list; race = race->next) {
     if (race->addr == addr && race->size == size) {
       atomic_store_relaxed(&race->addcount,
           atomic_load_relaxed(&race->addcount) + 1);
       return;
     }
   }
-  race = (ExpectRace *)internal_alloc(sizeof(ExpectRace));
+  race = New<ExpectRace>();
   race->addr = addr;
   race->size = size;
   race->file = f;
   race->line = l;
   race->desc[0] = 0;
   atomic_store_relaxed(&race->hitcount, 0);
   atomic_store_relaxed(&race->addcount, 1);
   if (desc) {
void INTERFACE_ATTRIBUTE AnnotateFlushExpectedRaces(char *f, int l) {
   while (dyn_ann_ctx->expect.next != &dyn_ann_ctx->expect) {
     ExpectRace *race = dyn_ann_ctx->expect.next;
     if (atomic_load_relaxed(&race->hitcount) == 0) {
       ctx->nmissed_expected++;
       ReportMissedExpectedRace(race);
     }
     race->prev->next = race->next;
     race->next->prev = race->prev;
-    internal_free(race);
+    Free(race);
   }
 }
 
 void INTERFACE_ATTRIBUTE AnnotateEnableRaceDetection(
     char *f, int l, int enable) {
   SCOPED_ANNOTATION(AnnotateEnableRaceDetection);
   // FIXME: Reconsider this functionality later. It may be irrelevant.
 }

compiler-rt/lib/tsan/rtl/tsan_mman.h

 void *user_pvalloc(ThreadState *thr, uptr pc, uptr sz);
 uptr user_alloc_usable_size(const void *p);
 
 // Invoking malloc/free hooks that may be installed by the user.
 void invoke_malloc_hook(void *ptr, uptr size);
 void invoke_free_hook(void *ptr);
 
 // For internal data structures.
-void *internal_alloc(uptr sz);
-void internal_free(void *p);
+void *Alloc(uptr sz);
+void FreeImpl(void *p);
 
 template <typename T>
-void DestroyAndFree(T *p) {
+T *New() {
+  return new (Alloc(sizeof(T))) T();
+}
+
+template <typename T>
+void Free(T *&p) {
+  if (p == nullptr)
+    return;
+  FreeImpl(p);
+  p = nullptr;
+}
+
+template <typename T>
+void DestroyAndFree(T *&p) {
+  if (p == nullptr)
+    return;
   p->~T();
-  internal_free(p);
+  Free(p);
 }
 
 }  // namespace __tsan
 #endif  // TSAN_MMAN_H

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

 void invoke_free_hook(void *ptr) {
   ThreadState *thr = cur_thread();
   if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
     return;
   __sanitizer_free_hook(ptr);
   RunFreeHooks(ptr);
 }
 
-void *internal_alloc(uptr sz) {
+void *Alloc(uptr sz) {
   ThreadState *thr = cur_thread();
   if (thr->nomalloc) {
     thr->nomalloc = 0;  // CHECK calls internal_malloc().
     CHECK(0);
   }
   return InternalAlloc(sz, &thr->proc()->internal_alloc_cache);
 }
 
-void internal_free(void *p) {
+void FreeImpl(void *p) {
   ThreadState *thr = cur_thread();
   if (thr->nomalloc) {
     thr->nomalloc = 0;  // CHECK calls internal_malloc().
     CHECK(0);
   }
   InternalFree(p, &thr->proc()->internal_alloc_cache);
 }
 

compiler-rt/lib/tsan/rtl/tsan_report.h

enum ReportType {
   ReportTypeMutexBadReadLock,
   ReportTypeMutexBadReadUnlock,
   ReportTypeSignalUnsafe,
   ReportTypeErrnoInSignal,
   ReportTypeDeadlock
 };
 
 struct ReportStack {
-  SymbolizedStack *frames;
-  bool suppressable;
-  static ReportStack *New();
-
- private:
-  ReportStack();
+  SymbolizedStack *frames = nullptr;
+  bool suppressable = false;
 };
 
 struct ReportMopMutex {
   u64 id;
   bool write;
 };
 
 struct ReportMop {
enum ReportLocationType {
   ReportLocationGlobal,
   ReportLocationHeap,
   ReportLocationStack,
   ReportLocationTLS,
   ReportLocationFD
 };
 
 struct ReportLocation {
-  ReportLocationType type;
-  DataInfo global;
-  uptr heap_chunk_start;
-  uptr heap_chunk_size;
-  uptr external_tag;
-  int tid;
-  int fd;
-  bool suppressable;
-  ReportStack *stack;
-
-  static ReportLocation *New(ReportLocationType type);
- private:
-  explicit ReportLocation(ReportLocationType type);
+  ReportLocationType type = ReportLocationGlobal;
+  DataInfo global = {};
+  uptr heap_chunk_start = 0;
+  uptr heap_chunk_size = 0;
+  uptr external_tag = 0;
+  int tid = kInvalidTid;
+  int fd = 0;
+  bool suppressable = false;
+  ReportStack *stack = nullptr;
 };
 
 struct ReportThread {
   int id;
   tid_t os_id;
   bool running;
   ThreadType thread_type;
   char *name;

compiler-rt/lib/tsan/rtl/tsan_report.cpp

 #include "tsan_rtl.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_stacktrace_printer.h"
 
 namespace __tsan {
 
-ReportStack::ReportStack() : frames(nullptr), suppressable(false) {}
-
-ReportStack *ReportStack::New() {
-  void *mem = internal_alloc(sizeof(ReportStack));
-  return new(mem) ReportStack();
-}
-
-ReportLocation::ReportLocation(ReportLocationType type)
-    : type(type), global(), heap_chunk_start(0), heap_chunk_size(0), tid(0),
-      fd(0), suppressable(false), stack(nullptr) {}
-
-ReportLocation *ReportLocation::New(ReportLocationType type) {
-  void *mem = internal_alloc(sizeof(ReportLocation));
-  return new(mem) ReportLocation(type);
-}
-
 class Decorator: public __sanitizer::SanitizerCommonDecorator {
  public:
   Decorator() : SanitizerCommonDecorator() { }
   const char *Access()     { return Blue(); }
   const char *ThreadDescription()    { return Cyan(); }
   const char *Location()   { return Green(); }
   const char *Sleep()   { return Yellow(); }
   const char *Mutex()   { return Magenta(); }

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

if (hdr_end < hdr + sizeof(Trace)) {
     ReleaseMemoryPagesToOS(hdr_end, hdr + sizeof(Trace));
     uptr unused = hdr + sizeof(Trace) - hdr_end;
     if (hdr_end != (uptr)MmapFixedNoAccess(hdr_end, unused)) {
       Report("ThreadSanitizer: failed to mprotect(%p, %p)\n",
           hdr_end, unused);
       CHECK("unable to mprotect" && 0);
     }
   }
-  void *mem = internal_alloc(sizeof(ThreadContext));
-  return new(mem) ThreadContext(tid);
+  return new (Alloc(sizeof(ThreadContext))) ThreadContext(tid);
 }
 
 #if !SANITIZER_GO
 static const u32 kThreadQuarantineSize = 16;
 #else
 static const u32 kThreadQuarantineSize = 64;
 #endif
 

 }
 #endif
 
 #if SANITIZER_GO
 NOINLINE
 void GrowShadowStack(ThreadState *thr) {
   const int sz = thr->shadow_stack_end - thr->shadow_stack;
   const int newsz = 2 * sz;
-  uptr *newstack = (uptr *)internal_alloc(newsz * sizeof(uptr));
+  auto newstack = (uptr *)Alloc(newsz * sizeof(uptr));
   internal_memcpy(newstack, thr->shadow_stack, sz * sizeof(uptr));
-  internal_free(thr->shadow_stack);
+  Free(thr->shadow_stack);
   thr->shadow_stack = newstack;
   thr->shadow_stack_pos = newstack + sz;
   thr->shadow_stack_end = newstack + newsz;
 }
 #endif
 
 u32 CurrentStackId(ThreadState *thr, uptr pc) {
   if (!thr->is_inited)  // May happen during bootstrap.

compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp

while (last->next) {
       last = last->next;
     }
     last->info.address = pc;  // restore original pc for report
     last->next = top;
     top = ent;
   }
   StackStripMain(top);
 
-  ReportStack *stack = ReportStack::New();
+  auto *stack = New<ReportStack>();
   stack->frames = top;
   return stack;
 }
 
 bool ShouldReport(ThreadState *thr, ReportType typ) {
   // We set thr->suppress_reports in the fork context.
   // Taking any locking in the fork context can lead to deadlocks.
   // If any locks are already taken, it's too late to do this check.
case ReportTypeMutexDestroyLocked:
       return flags()->report_destroy_locked;
     default:
       return true;
   }
 }
 
 ScopedReportBase::ScopedReportBase(ReportType typ, uptr tag) {
   ctx->thread_registry.CheckLocked();
-  void *mem = internal_alloc(sizeof(ReportDesc));
-  rep_ = new(mem) ReportDesc;
+  rep_ = New<ReportDesc>();
   rep_->typ = typ;
   rep_->tag = tag;
   ctx->report_mtx.Lock();
 }
 
 ScopedReportBase::~ScopedReportBase() {
   ctx->report_mtx.Unlock();
   DestroyAndFree(rep_);
-  rep_ = nullptr;
 }
 
 void ScopedReportBase::AddStack(StackTrace stack, bool suppressable) {
   ReportStack **rs = rep_->stacks.PushBack();
   *rs = SymbolizeStack(stack);
   (*rs)->suppressable = suppressable;
 }
 
 void ScopedReportBase::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s,
                                        StackTrace stack, const MutexSet *mset) {
-  void *mem = internal_alloc(sizeof(ReportMop));
-  ReportMop *mop = new(mem) ReportMop;
+  auto *mop = New<ReportMop>();
   rep_->mops.PushBack(mop);
   mop->tid = s.tid();
   mop->addr = addr + s.addr0();
   mop->size = s.size();
   mop->write = s.IsWrite();
   mop->atomic = s.IsAtomic();
   mop->stack = SymbolizeStack(stack);
   mop->external_tag = external_tag;
void ScopedReportBase::AddUniqueTid(int unique_tid) {
   rep_->unique_tids.PushBack(unique_tid);
 }
 
 void ScopedReportBase::AddThread(const ThreadContext *tctx, bool suppressable) {
   for (uptr i = 0; i < rep_->threads.Size(); i++) {
     if ((u32)rep_->threads[i]->id == tctx->tid)
       return;
   }
-  void *mem = internal_alloc(sizeof(ReportThread));
-  ReportThread *rt = new(mem) ReportThread;
+  auto *rt = New<ReportThread>();
   rep_->threads.PushBack(rt);
   rt->id = tctx->tid;
   rt->os_id = tctx->os_id;
   rt->running = (tctx->status == ThreadStatusRunning);
   rt->name = internal_strdup(tctx->name);
   rt->parent_tid = tctx->parent_tid;
   rt->thread_type = tctx->thread_type;
   rt->stack = 0;

 #endif
 }
 
 void ScopedReportBase::AddMutex(const SyncVar *s) {
   for (uptr i = 0; i < rep_->mutexes.Size(); i++) {
     if (rep_->mutexes[i]->id == s->uid)
       return;
   }
-  void *mem = internal_alloc(sizeof(ReportMutex));
-  ReportMutex *rm = new(mem) ReportMutex;
+  auto *rm = New<ReportMutex>();
   rep_->mutexes.PushBack(rm);
   rm->id = s->uid;
   rm->addr = s->addr;
   rm->destroyed = false;
   rm->stack = SymbolizeStackId(s->creation_stack_id);
 }
 
 u64 ScopedReportBase::AddMutex(u64 id) NO_THREAD_SAFETY_ANALYSIS {
u64 ScopedReportBase::AddMutex(u64 id) NO_THREAD_SAFETY_ANALYSIS {
   return mid;
 }
 
 void ScopedReportBase::AddDeadMutex(u64 id) {
   for (uptr i = 0; i < rep_->mutexes.Size(); i++) {
     if (rep_->mutexes[i]->id == id)
       return;
   }
-  void *mem = internal_alloc(sizeof(ReportMutex));
-  ReportMutex *rm = new(mem) ReportMutex;
+  auto *rm = New<ReportMutex>();
   rep_->mutexes.PushBack(rm);
   rm->id = id;
   rm->addr = 0;
   rm->destroyed = true;
   rm->stack = 0;
 }
 
 void ScopedReportBase::AddLocation(uptr addr, uptr size) {
   if (addr == 0)
     return;
 #if !SANITIZER_GO
   int fd = -1;
   int creat_tid = kInvalidTid;
   u32 creat_stack = 0;
   if (FdLocation(addr, &fd, &creat_tid, &creat_stack)) {
-    ReportLocation *loc = ReportLocation::New(ReportLocationFD);
+    auto *loc = New<ReportLocation>();
+    loc->type = ReportLocationFD;
     loc->fd = fd;
     loc->tid = creat_tid;
     loc->stack = SymbolizeStackId(creat_stack);
     rep_->locs.PushBack(loc);
     ThreadContext *tctx = FindThreadByUidLocked(creat_tid);
     if (tctx)
       AddThread(tctx);
     return;
   }
   MBlock *b = 0;
   uptr block_begin = 0;
   Allocator *a = allocator();
   if (a->PointerIsMine((void*)addr)) {
     block_begin = (uptr)a->GetBlockBegin((void *)addr);
     if (block_begin)
       b = ctx->metamap.GetBlock(block_begin);
   }
   if (!b)
     b = JavaHeapBlock(addr, &block_begin);
   if (b != 0) {
     ThreadContext *tctx = FindThreadByTidLocked(b->tid);
-    ReportLocation *loc = ReportLocation::New(ReportLocationHeap);
+    auto *loc = New<ReportLocation>();
+    loc->type = ReportLocationHeap;
     loc->heap_chunk_start = (uptr)allocator()->GetBlockBegin((void *)addr);
     loc->heap_chunk_size = b->siz;
     loc->external_tag = b->tag;
     loc->tid = tctx ? tctx->tid : b->tid;
     loc->stack = SymbolizeStackId(b->stk);
     rep_->locs.PushBack(loc);
     if (tctx)
       AddThread(tctx);
     return;
   }
   bool is_stack = false;
   if (ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack)) {
-    ReportLocation *loc =
-        ReportLocation::New(is_stack ? ReportLocationStack : ReportLocationTLS);
+    auto *loc = New<ReportLocation>();
+    loc->type = is_stack ? ReportLocationStack : ReportLocationTLS;
     loc->tid = tctx->tid;
     rep_->locs.PushBack(loc);
     AddThread(tctx);
   }
 #endif
   if (ReportLocation *loc = SymbolizeData(addr)) {
     loc->suppressable = true;
     rep_->locs.PushBack(loc);

 // tail-call to PrintCurrentStackSlow breaks this assumption because
 // __sanitizer_print_stack_trace disappears after tail-call.
 // However, this solution is not reliable enough, please see dvyukov's comment
 // http://reviews.llvm.org/D19148#406208
 // Also see PR27280 comment 2 and 3 for breaking examples and analysis.
 ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) {
 #if !SANITIZER_GO
   uptr bp = GET_CURRENT_FRAME();
-  BufferedStackTrace *ptrace =
-      new (internal_alloc(sizeof(BufferedStackTrace))) BufferedStackTrace();
+  auto *ptrace = New<BufferedStackTrace>();
   ptrace->Unwind(pc, bp, nullptr, false);
 
   for (uptr i = 0; i < ptrace->size / 2; i++) {
     uptr tmp = ptrace->trace_buffer[i];
     ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1];
     ptrace->trace_buffer[ptrace->size - i - 1] = tmp;
   }
   PrintStack(SymbolizeStack(*ptrace));

compiler-rt/lib/tsan/rtl/tsan_rtl_thread.cpp

new(thr) ThreadState(ctx, tid, unique_id, epoch0, reuse_count,
       args->stk_addr, args->stk_size, args->tls_addr, args->tls_size);
 #if !SANITIZER_GO
   thr->shadow_stack = &ThreadTrace(thr->tid)->shadow_stack[0];
   thr->shadow_stack_pos = thr->shadow_stack;
   thr->shadow_stack_end = thr->shadow_stack + kShadowStackSize;
 #else
   // Setup dynamic shadow stack.
   const int kInitStackSize = 8;
-  thr->shadow_stack = (uptr *)internal_alloc(kInitStackSize * sizeof(uptr));
+  thr->shadow_stack = (uptr *)Alloc(kInitStackSize * sizeof(uptr));
   thr->shadow_stack_pos = thr->shadow_stack;
   thr->shadow_stack_end = thr->shadow_stack + kInitStackSize;
 #endif
   if (common_flags()->detect_deadlocks)
     thr->dd_lt = ctx->dd->CreateLogicalThread(unique_id);
   thr->fast_state.SetHistorySize(flags()->history_size);
   // Commit switch to the new part of the trace.
   // TraceAddEvent will reset stack0/mset0 in the new part for us.
   TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
 
   thr->fast_synch_epoch = epoch0;
   AcquireImpl(thr, 0, &sync);
   sync.Reset(&thr->proc()->clock_cache);
   thr->is_inited = true;
   DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx "
           "tls_addr=%zx tls_size=%zx\n",
           tid, (uptr)epoch0, args->stk_addr, args->stk_size,
           args->tls_addr, args->tls_size);
 }
 
 void ThreadContext::OnFinished() {
 #if SANITIZER_GO
-  internal_free(thr->shadow_stack);
-  thr->shadow_stack = nullptr;
+  Free(thr->shadow_stack);
   thr->shadow_stack_pos = nullptr;
   thr->shadow_stack_end = nullptr;
 #endif
   if (!detached) {
     thr->fast_state.IncrementEpoch();
     // Can't increment epoch w/o writing to the trace as well.
     TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
     ReleaseImpl(thr, 0, &sync);

 void FiberSwitchImpl(ThreadState *from, ThreadState *to) {
   Processor *proc = from->proc();
   ProcUnwire(proc, from);
   ProcWire(proc, to);
   set_cur_thread(to);
 }
 
 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags) {
-  void *mem = internal_alloc(sizeof(ThreadState));
+  void *mem = Alloc(sizeof(ThreadState));
   ThreadState *fiber = static_cast<ThreadState *>(mem);
   internal_memset(fiber, 0, sizeof(*fiber));
   int tid = ThreadCreate(thr, pc, 0, true);
   FiberSwitchImpl(thr, fiber);
   ThreadStart(fiber, tid, 0, ThreadType::Fiber);
   FiberSwitchImpl(fiber, thr);
   return fiber;
 }
 
 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber) {
   FiberSwitchImpl(thr, fiber);
   ThreadFinish(fiber);
   FiberSwitchImpl(fiber, thr);
-  internal_free(fiber);
+  Free(fiber);
 }
 
 void FiberSwitch(ThreadState *thr, uptr pc,
                  ThreadState *fiber, unsigned flags) {
   if (!(flags & FiberSwitchFlagNoSync))
     Release(thr, pc, (uptr)fiber);
   FiberSwitchImpl(thr, fiber);
   if (!(flags & FiberSwitchFlagNoSync))
     Acquire(fiber, pc, (uptr)fiber);
 }
 #endif
 
 }  // namespace __tsan

compiler-rt/lib/tsan/rtl/tsan_stack_trace.cpp

 VarSizeStackTrace::VarSizeStackTrace()
     : StackTrace(nullptr, 0), trace_buffer(nullptr) {}
 
 VarSizeStackTrace::~VarSizeStackTrace() {
   ResizeBuffer(0);
 }
 
 void VarSizeStackTrace::ResizeBuffer(uptr new_size) {
-  if (trace_buffer) {
-    internal_free(trace_buffer);
-  }
-  trace_buffer =
-      (new_size > 0)
-          ? (uptr *)internal_alloc(new_size * sizeof(trace_buffer[0]))
+  Free(trace_buffer);
+  trace_buffer = (new_size > 0)
+                     ? (uptr *)Alloc(new_size * sizeof(trace_buffer[0]))
                      : nullptr;
   trace = trace_buffer;
   size = new_size;
 }
 
 void VarSizeStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
   ResizeBuffer(cnt + !!extra_top_pc);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)

compiler-rt/lib/tsan/rtl/tsan_symbolize.cpp

SymbolizedStack *SymbolizeCode(uptr addr) {
   }
   return Symbolizer::GetOrInit()->SymbolizePC(addr);
 }
 
 ReportLocation *SymbolizeData(uptr addr) {
   DataInfo info;
   if (!Symbolizer::GetOrInit()->SymbolizeData(addr, &info))
     return 0;
-  ReportLocation *ent = ReportLocation::New(ReportLocationGlobal);
+  auto *ent = New<ReportLocation>();
+  ent->type = ReportLocationGlobal;
   internal_memcpy(&ent->global, &info, sizeof(info));
   return ent;
 }
 
 void SymbolizeFlush() {
   Symbolizer::GetOrInit()->Flush();
 }
 
 }  // namespace __tsan

compiler-rt/lib/tsan/tests/unit/tsan_mman_test.cpp

 #include <sanitizer/allocator_interface.h>
 #include "tsan_mman.h"
 #include "tsan_rtl.h"
 #include "gtest/gtest.h"
 
 namespace __tsan {
 
 TEST(Mman, Internal) {
-  char *p = (char *)internal_alloc(10);
+  char *p = (char *)Alloc(10);
   EXPECT_NE(p, (char*)0);
-  char *p2 = (char *)internal_alloc(20);
+  char *p2 = (char *)Alloc(20);
   EXPECT_NE(p2, (char*)0);
   EXPECT_NE(p2, p);
   for (int i = 0; i < 10; i++) {
     p[i] = 42;
   }
   for (int i = 0; i < 20; i++) {
     ((char*)p2)[i] = 42;
   }
-  internal_free(p);
-  internal_free(p2);
+  Free(p);
+  Free(p2);
 }
 
 TEST(Mman, User) {
   ThreadState *thr = cur_thread();
   uptr pc = 0;
   char *p = (char*)user_alloc(thr, pc, 10);
   EXPECT_NE(p, (char*)0);
   char *p2 = (char*)user_alloc(thr, pc, 20);