contrib/compiler-rt/lib/tsan/go/tsan_go.cc

   1 //===-- tsan_go.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 // ThreadSanitizer runtime for Go language.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "tsan_rtl.h"
  15 #include "tsan_symbolize.h"
  16 #include "sanitizer_common/sanitizer_common.h"
  17 #include <stdlib.h>
  18
  19 namespace __tsan {
  20
  21 void InitializeInterceptors() {
  22 }
  23
  24 void InitializeDynamicAnnotations() {
  25 }
  26
  27 bool IsExpectedReport(uptr addr, uptr size) {
  28   return false;
  29 }
  30
  31 void *internal_start_thread(void(*func)(void*), void *arg) {
  32   return 0;
  33 }
  34
  35 void internal_join_thread(void *th) {
  36 }
  37
  38 ReportLocation *SymbolizeData(uptr addr) {
  39   return 0;
  40 }
  41
  42 void *internal_alloc(MBlockType typ, uptr sz) {
  43   return InternalAlloc(sz);
  44 }
  45
  46 void internal_free(void *p) {
  47   InternalFree(p);
  48 }
  49
  50 struct SymbolizeContext {
  51   uptr pc;
  52   char *func;
  53   char *file;
  54   uptr line;
  55   uptr off;
  56   uptr res;
  57 };
  58
  59 // Callback into Go.
  60 static void (*symbolize_cb)(SymbolizeContext *ctx);
  61
  62 SymbolizedStack *SymbolizeCode(uptr addr) {
  63   SymbolizedStack *s = SymbolizedStack::New(addr);
  64   SymbolizeContext ctx;
  65   internal_memset(&ctx, 0, sizeof(ctx));
  66   ctx.pc = addr;
  67   symbolize_cb(&ctx);
  68   if (ctx.res) {
  69     AddressInfo &info = s->info;
  70     info.module_offset = ctx.off;
  71     info.function = internal_strdup(ctx.func ? ctx.func : "??");
  72     info.file = internal_strdup(ctx.file ? ctx.file : "-");
  73     info.line = ctx.line;
  74     info.column = 0;
  75   }
  76   return s;
  77 }
  78
  79 extern "C" {
  80
  81 static ThreadState *main_thr;
  82 static bool inited;
  83
  84 static ThreadState *AllocGoroutine() {
  85   ThreadState *thr = (ThreadState*)internal_alloc(MBlockThreadContex,
  86       sizeof(ThreadState));
  87   internal_memset(thr, 0, sizeof(*thr));
  88   return thr;
  89 }
  90
  91 void __tsan_init(ThreadState **thrp, void (*cb)(SymbolizeContext *cb)) {
  92   symbolize_cb = cb;
  93   ThreadState *thr = AllocGoroutine();
  94   main_thr = *thrp = thr;
  95   Initialize(thr);
  96   inited = true;
  97 }
  98
  99 void __tsan_fini() {
 100   // FIXME: Not necessary thread 0.
 101   ThreadState *thr = main_thr;
 102   int res = Finalize(thr);
 103   exit(res);
 104 }
 105
 106 void __tsan_map_shadow(uptr addr, uptr size) {
 107   MapShadow(addr, size);
 108 }
 109
 110 void __tsan_read(ThreadState *thr, void *addr, void *pc) {
 111   MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
 112 }
 113
 114 void __tsan_read_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
 115   if (callpc != 0)
 116     FuncEntry(thr, callpc);
 117   MemoryRead(thr, (uptr)pc, (uptr)addr, kSizeLog1);
 118   if (callpc != 0)
 119     FuncExit(thr);
 120 }
 121
 122 void __tsan_write(ThreadState *thr, void *addr, void *pc) {
 123   MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
 124 }
 125
 126 void __tsan_write_pc(ThreadState *thr, void *addr, uptr callpc, uptr pc) {
 127   if (callpc != 0)
 128     FuncEntry(thr, callpc);
 129   MemoryWrite(thr, (uptr)pc, (uptr)addr, kSizeLog1);
 130   if (callpc != 0)
 131     FuncExit(thr);
 132 }
 133
 134 void __tsan_read_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
 135   MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, false);
 136 }
 137
 138 void __tsan_write_range(ThreadState *thr, void *addr, uptr size, uptr pc) {
 139   MemoryAccessRange(thr, (uptr)pc, (uptr)addr, size, true);
 140 }
 141
 142 void __tsan_func_enter(ThreadState *thr, void *pc) {
 143   FuncEntry(thr, (uptr)pc);
 144 }
 145
 146 void __tsan_func_exit(ThreadState *thr) {
 147   FuncExit(thr);
 148 }
 149
 150 void __tsan_malloc(void *p, uptr sz) {
 151   if (!inited)
 152     return;
 153   MemoryResetRange(0, 0, (uptr)p, sz);
 154 }
 155
 156 void __tsan_go_start(ThreadState *parent, ThreadState **pthr, void *pc) {
 157   ThreadState *thr = AllocGoroutine();
 158   *pthr = thr;
 159   int goid = ThreadCreate(parent, (uptr)pc, 0, true);
 160   ThreadStart(thr, goid, 0);
 161 }
 162
 163 void __tsan_go_end(ThreadState *thr) {
 164   ThreadFinish(thr);
 165   internal_free(thr);
 166 }
 167
 168 void __tsan_acquire(ThreadState *thr, void *addr) {
 169   Acquire(thr, 0, (uptr)addr);
 170 }
 171
 172 void __tsan_release(ThreadState *thr, void *addr) {
 173   ReleaseStore(thr, 0, (uptr)addr);
 174 }
 175
 176 void __tsan_release_merge(ThreadState *thr, void *addr) {
 177   Release(thr, 0, (uptr)addr);
 178 }
 179
 180 void __tsan_finalizer_goroutine(ThreadState *thr) {
 181   AcquireGlobal(thr, 0);
 182 }
 183
 184 void __tsan_mutex_before_lock(ThreadState *thr, uptr addr, uptr write) {
 185 }
 186
 187 void __tsan_mutex_after_lock(ThreadState *thr, uptr addr, uptr write) {
 188   if (write)
 189     MutexLock(thr, 0, addr);
 190   else
 191     MutexReadLock(thr, 0, addr);
 192 }
 193
 194 void __tsan_mutex_before_unlock(ThreadState *thr, uptr addr, uptr write) {
 195   if (write)
 196     MutexUnlock(thr, 0, addr);
 197   else
 198     MutexReadUnlock(thr, 0, addr);
 199 }
 200
 201 void __tsan_go_ignore_sync_begin(ThreadState *thr) {
 202   ThreadIgnoreSyncBegin(thr, 0);
 203 }
 204
 205 void __tsan_go_ignore_sync_end(ThreadState *thr) {
 206   ThreadIgnoreSyncEnd(thr, 0);
 207 }
 208
 209 }  // extern "C"
 210 }  // namespace __tsan
 211
 212 namespace __sanitizer {
 213
 214 void SymbolizerPrepareForSandboxing() {
 215   // Nothing to do here for Go.
 216 }
 217
 218 }  // namespace __sanitizer