reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

  167 struct ThreadState;

  217 struct ThreadState;

References

   45 void InsertShadowStackFrameForTag(ThreadState *thr, uptr tag) {
   59 typedef void(*AccessFunc)(ThreadState *, uptr, uptr, int);
   62   ThreadState *thr = cur_thread();

   49 static FdSync *allocsync(ThreadState *thr, uptr pc) {
   62 static void unref(ThreadState *thr, uptr pc, FdSync *s) {
   73 static FdDesc *fddesc(ThreadState *thr, uptr pc, int fd) {
   94 static void init(ThreadState *thr, uptr pc, int fd, FdSync *s,
  128 void FdOnFork(ThreadState *thr, uptr pc) {
  160 void FdAcquire(ThreadState *thr, uptr pc, int fd) {
  171 void FdRelease(ThreadState *thr, uptr pc, int fd) {
  182 void FdAccess(ThreadState *thr, uptr pc, int fd) {
  190 void FdClose(ThreadState *thr, uptr pc, int fd, bool write) {
  218 void FdFileCreate(ThreadState *thr, uptr pc, int fd) {
  225 void FdDup(ThreadState *thr, uptr pc, int oldfd, int newfd, bool write) {
  236 void FdPipeCreate(ThreadState *thr, uptr pc, int rfd, int wfd) {
  244 void FdEventCreate(ThreadState *thr, uptr pc, int fd) {
  251 void FdSignalCreate(ThreadState *thr, uptr pc, int fd) {
  258 void FdInotifyCreate(ThreadState *thr, uptr pc, int fd) {
  265 void FdPollCreate(ThreadState *thr, uptr pc, int fd) {
  272 void FdSocketCreate(ThreadState *thr, uptr pc, int fd) {
  280 void FdSocketAccept(ThreadState *thr, uptr pc, int fd, int newfd) {
  289 void FdSocketConnecting(ThreadState *thr, uptr pc, int fd) {
  297 void FdSocketConnect(ThreadState *thr, uptr pc, int fd) {

   41 void FdAcquire(ThreadState *thr, uptr pc, int fd);
   42 void FdRelease(ThreadState *thr, uptr pc, int fd);
   43 void FdAccess(ThreadState *thr, uptr pc, int fd);
   44 void FdClose(ThreadState *thr, uptr pc, int fd, bool write = true);
   45 void FdFileCreate(ThreadState *thr, uptr pc, int fd);
   46 void FdDup(ThreadState *thr, uptr pc, int oldfd, int newfd, bool write);
   47 void FdPipeCreate(ThreadState *thr, uptr pc, int rfd, int wfd);
   48 void FdEventCreate(ThreadState *thr, uptr pc, int fd);
   49 void FdSignalCreate(ThreadState *thr, uptr pc, int fd);
   50 void FdInotifyCreate(ThreadState *thr, uptr pc, int fd);
   51 void FdPollCreate(ThreadState *thr, uptr pc, int fd);
   52 void FdSocketCreate(ThreadState *thr, uptr pc, int fd);
   53 void FdSocketAccept(ThreadState *thr, uptr pc, int fd, int newfd);
   54 void FdSocketConnecting(ThreadState *thr, uptr pc, int fd);
   55 void FdSocketConnect(ThreadState *thr, uptr pc, int fd);
   57 void FdOnFork(ThreadState *thr, uptr pc);

   11   ScopedInterceptor(ThreadState *thr, const char *fname, uptr pc);
   16   ThreadState *const thr_;

  239 static ThreadSignalContext *SigCtx(ThreadState *thr) {
  249 ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
  320   explicit BlockingCall(ThreadState *thr)
  343   ThreadState *thr;
  397 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
  418 static int setup_at_exit_wrapper(ThreadState *thr, uptr pc, void(*f)(),
  449   ThreadState *thr = cur_thread();
  478 static void JmpBufGarbageCollect(ThreadState *thr, uptr sp) {
  490 static void SetJmp(ThreadState *thr, uptr sp) {
  508 static void LongJmp(ThreadState *thr, uptr *env) {
  766 static void *mmap_interceptor(ThreadState *thr, uptr pc, Mmap real_mmap,
  889   ThreadState *thr = cur_thread();
  933     ThreadState *thr = cur_thread();
 1120   ThreadState *thr;
 1147 static int cond_wait(ThreadState *thr, uptr pc, ScopedInterceptor *si,
 1878 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
 1940 void ProcessPendingSignals(ThreadState *thr) {
 1976   ThreadState *thr = cur_thread();
 2138   ThreadState *thr;
 2180 static int OnExit(ThreadState *thr) {
 2187   ThreadState *thr;
 2193 static void HandleRecvmsg(ThreadState *thr, uptr pc,
 2418   ThreadState *thr;
 2420   explicit ScopedSyscall(ThreadState *thr)
 2538   ThreadState *thr = cur_thread();
 2595   ThreadState *thr = cur_thread();

  397 void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  399 void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  401 void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  403 void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  405 void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  407 void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  409 void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  411 void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
  413 void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,
  416 void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,

   33   ScopedAnnotation(ThreadState *thr, const char *aname, uptr pc)
   44   ThreadState *const thr_;

  222 static T AtomicLoad(ThreadState *thr, uptr pc, const volatile T *a, morder mo) {
  258 static void AtomicStore(ThreadState *thr, uptr pc, volatile T *a, T v,
  281 static T AtomicRMW(ThreadState *thr, uptr pc, volatile T *a, T v, morder mo) {
  338 static T AtomicExchange(ThreadState *thr, uptr pc, volatile T *a, T v,
  344 static T AtomicFetchAdd(ThreadState *thr, uptr pc, volatile T *a, T v,
  350 static T AtomicFetchSub(ThreadState *thr, uptr pc, volatile T *a, T v,
  356 static T AtomicFetchAnd(ThreadState *thr, uptr pc, volatile T *a, T v,
  362 static T AtomicFetchOr(ThreadState *thr, uptr pc, volatile T *a, T v,
  368 static T AtomicFetchXor(ThreadState *thr, uptr pc, volatile T *a, T v,
  374 static T AtomicFetchNand(ThreadState *thr, uptr pc, volatile T *a, T v,
  403 static bool AtomicCAS(ThreadState *thr, uptr pc,
  436 static T AtomicCAS(ThreadState *thr, uptr pc,
  447 static void AtomicFence(ThreadState *thr, uptr pc, morder mo) {
  491   ScopedAtomic(ThreadState *thr, uptr pc, const volatile void *a,
  502   ThreadState *thr_;
  505 static void AtomicStatInc(ThreadState *thr, uptr size, morder mo, StatType t) {

   87     ThreadState *thr = cur_thread();
   96   ThreadState *thr = cur_thread();

   40   ScopedJavaFunc(ThreadState *thr, uptr pc)
   52   ThreadState *thr_;

   86   ThreadState *thr = cur_thread();
  109   ThreadState *thr = cur_thread();
  139 static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
  155 void *user_alloc_internal(ThreadState *thr, uptr pc, uptr sz, uptr align,
  178 void user_free(ThreadState *thr, uptr pc, void *p, bool signal) {
  187 void *user_alloc(ThreadState *thr, uptr pc, uptr sz) {
  191 void *user_calloc(ThreadState *thr, uptr pc, uptr size, uptr n) {
  204 void *user_reallocarray(ThreadState *thr, uptr pc, void *p, uptr size, uptr n) {
  214 void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write) {
  223 void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write) {
  231 void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
  249 void *user_memalign(ThreadState *thr, uptr pc, uptr align, uptr sz) {
  260 int user_posix_memalign(ThreadState *thr, uptr pc, void **memptr, uptr align,
  277 void *user_aligned_alloc(ThreadState *thr, uptr pc, uptr align, uptr sz) {
  288 void *user_valloc(ThreadState *thr, uptr pc, uptr sz) {
  292 void *user_pvalloc(ThreadState *thr, uptr pc, uptr sz) {
  318   ThreadState *thr = cur_thread();
  326   ThreadState *thr = cur_thread();
  334   ThreadState *thr = cur_thread();
  343   ThreadState *thr = cur_thread();
  389   ThreadState *thr = cur_thread();

   29 void *user_alloc_internal(ThreadState *thr, uptr pc, uptr sz,
   32 void user_free(ThreadState *thr, uptr pc, void *p, bool signal = true);
   34 void *user_alloc(ThreadState *thr, uptr pc, uptr sz);
   35 void *user_calloc(ThreadState *thr, uptr pc, uptr sz, uptr n);
   36 void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz);
   37 void *user_reallocarray(ThreadState *thr, uptr pc, void *p, uptr sz, uptr n);
   38 void *user_memalign(ThreadState *thr, uptr pc, uptr align, uptr sz);
   39 int user_posix_memalign(ThreadState *thr, uptr pc, void **memptr, uptr align,
   41 void *user_aligned_alloc(ThreadState *thr, uptr pc, uptr align, uptr sz);
   42 void *user_valloc(ThreadState *thr, uptr pc, uptr sz);
   43 void *user_pvalloc(ThreadState *thr, uptr pc, uptr sz);

  174 void CheckNoLocks(ThreadState *thr) {

   86 void CheckNoLocks(ThreadState *thr);

 1017 void ImitateTlsWrite(ThreadState *thr, uptr tls_addr, uptr tls_size);

  427 void ImitateTlsWrite(ThreadState *thr, uptr tls_addr, uptr tls_size) {

   49 THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
  243 void UnmapShadow(ThreadState *thr, uptr addr, uptr size) {
  350 void Initialize(ThreadState *thr) {
  442 int Finalize(ThreadState *thr) {
  494 void ForkBefore(ThreadState *thr, uptr pc) {
  499 void ForkParentAfter(ThreadState *thr, uptr pc) {
  504 void ForkChildAfter(ThreadState *thr, uptr pc) {
  541 u32 CurrentStackId(ThreadState *thr, uptr pc) {
  561 void TraceSwitch(ThreadState *thr) {
  581 uptr TraceTopPC(ThreadState *thr) {
  623 void HandleRace(ThreadState *thr, u64 *shadow_mem,
  635 static inline bool HappensBefore(Shadow old, ThreadState *thr) {
  640 void MemoryAccessImpl1(ThreadState *thr, uptr addr,
  709 void UnalignedMemoryAccess(ThreadState *thr, uptr pc, uptr addr,
  818 void MemoryAccess(ThreadState *thr, uptr pc, uptr addr,
  884 void MemoryAccessImpl(ThreadState *thr, uptr addr,
  900 static void MemoryRangeSet(ThreadState *thr, uptr pc, uptr addr, uptr size,
  961 void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size) {
  965 void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size) {
  987 void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size) {
  999 void MemoryRangeImitateWriteOrResetRange(ThreadState *thr, uptr pc, uptr addr,
 1008 void FuncEntry(ThreadState *thr, uptr pc) {
 1030 void FuncExit(ThreadState *thr) {
 1045 void ThreadIgnoreBegin(ThreadState *thr, uptr pc, bool save_stack) {
 1056 void ThreadIgnoreEnd(ThreadState *thr, uptr pc) {
 1071   ThreadState *thr = cur_thread();
 1076 void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc, bool save_stack) {
 1086 void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc) {

  343   ThreadState *thr; // currently wired thread, or nullptr
  381   ThreadState* current;
  465 INLINE ThreadState *cur_thread() {
  469   ThreadState *thr = reinterpret_cast<ThreadState *>(cur_thread_placeholder);
  473 INLINE void set_cur_thread(ThreadState *thr) {
  484   ThreadState *thr;
  647 void ObtainCurrentStack(ThreadState *thr, uptr toppc, StackTraceTy *stack,
  669 void ALWAYS_INLINE StatInc(ThreadState *thr, StatType typ, u64 n = 1) {
  674 void ALWAYS_INLINE StatSet(ThreadState *thr, StatType typ, u64 n) {
  683 void UnmapShadow(ThreadState *thr, uptr addr, uptr size);
  689 void ForkBefore(ThreadState *thr, uptr pc);
  690 void ForkParentAfter(ThreadState *thr, uptr pc);
  691 void ForkChildAfter(ThreadState *thr, uptr pc);
  693 void ReportRace(ThreadState *thr);
  694 bool OutputReport(ThreadState *thr, const ScopedReport &srep);
  711 u32 CurrentStackId(ThreadState *thr, uptr pc);
  713 void PrintCurrentStack(ThreadState *thr, uptr pc);
  716 void Initialize(ThreadState *thr);
  718 int Finalize(ThreadState *thr);
  720 void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write);
  721 void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write);
  723 void MemoryAccess(ThreadState *thr, uptr pc, uptr addr,
  725 void MemoryAccessImpl(ThreadState *thr, uptr addr,
  728 void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
  730 void MemoryAccessRangeStep(ThreadState *thr, uptr pc, uptr addr,
  732 void UnalignedMemoryAccess(ThreadState *thr, uptr pc, uptr addr,
  740 void ALWAYS_INLINE MemoryRead(ThreadState *thr, uptr pc,
  745 void ALWAYS_INLINE MemoryWrite(ThreadState *thr, uptr pc,
  750 void ALWAYS_INLINE MemoryReadAtomic(ThreadState *thr, uptr pc,
  755 void ALWAYS_INLINE MemoryWriteAtomic(ThreadState *thr, uptr pc,
  760 void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size);
  761 void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size);
  762 void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size);
  763 void MemoryRangeImitateWriteOrResetRange(ThreadState *thr, uptr pc, uptr addr,
  766 void ThreadIgnoreBegin(ThreadState *thr, uptr pc, bool save_stack = true);
  767 void ThreadIgnoreEnd(ThreadState *thr, uptr pc);
  768 void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc, bool save_stack = true);
  769 void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc);
  771 void FuncEntry(ThreadState *thr, uptr pc);
  772 void FuncExit(ThreadState *thr);
  774 int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached);
  775 void ThreadStart(ThreadState *thr, int tid, tid_t os_id,
  777 void ThreadFinish(ThreadState *thr);
  778 int ThreadTid(ThreadState *thr, uptr pc, uptr uid);
  779 void ThreadJoin(ThreadState *thr, uptr pc, int tid);
  780 void ThreadDetach(ThreadState *thr, uptr pc, int tid);
  781 void ThreadFinalize(ThreadState *thr);
  782 void ThreadSetName(ThreadState *thr, const char *name);
  783 int ThreadCount(ThreadState *thr);
  784 void ProcessPendingSignals(ThreadState *thr);
  785 void ThreadNotJoined(ThreadState *thr, uptr pc, int tid, uptr uid);
  789 void ProcWire(Processor *proc, ThreadState *thr);
  790 void ProcUnwire(Processor *proc, ThreadState *thr);
  794 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  795 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  796 void MutexPreLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  797 void MutexPostLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0,
  799 int  MutexUnlock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  800 void MutexPreReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  801 void MutexPostReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz = 0);
  802 void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr);
  803 void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr);
  804 void MutexRepair(ThreadState *thr, uptr pc, uptr addr);  // call on EOWNERDEAD
  805 void MutexInvalidAccess(ThreadState *thr, uptr pc, uptr addr);
  807 void Acquire(ThreadState *thr, uptr pc, uptr addr);
  814 void AcquireGlobal(ThreadState *thr, uptr pc);
  815 void Release(ThreadState *thr, uptr pc, uptr addr);
  816 void ReleaseStore(ThreadState *thr, uptr pc, uptr addr);
  817 void AfterSleep(ThreadState *thr, uptr pc);
  818 void AcquireImpl(ThreadState *thr, uptr pc, SyncClock *c);
  819 void ReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c);
  820 void ReleaseStoreImpl(ThreadState *thr, uptr pc, SyncClock *c);
  821 void AcquireReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c);
  844 void TraceSwitch(ThreadState *thr);
  845 uptr TraceTopPC(ThreadState *thr);
  851 void ALWAYS_INLINE TraceAddEvent(ThreadState *thr, FastState fs,
  879 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags);
  879 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags);
  880 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber);
  880 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber);
  881 void FiberSwitch(ThreadState *thr, uptr pc, ThreadState *fiber, unsigned flags);
  881 void FiberSwitch(ThreadState *thr, uptr pc, ThreadState *fiber, unsigned flags);

   25 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r);
   28   ThreadState *thr;
   31   Callback(ThreadState *thr, uptr pc)
   42 void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s) {
   48 static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ,
   64 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
   80 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  142 void MutexPreLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  158 void MutexPostLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz, int rec) {
  213 int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  256 void MutexPreReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  268 void MutexPostReadLock(ThreadState *thr, uptr pc, uptr addr, u32 flagz) {
  308 void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr) {
  340 void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr) {
  387 void MutexRepair(ThreadState *thr, uptr pc, uptr addr) {
  395 void MutexInvalidAccess(ThreadState *thr, uptr pc, uptr addr) {
  403 void Acquire(ThreadState *thr, uptr pc, uptr addr) {
  415   ThreadState *thr = reinterpret_cast<ThreadState*>(arg);
  423 void AcquireGlobal(ThreadState *thr, uptr pc) {
  432 void Release(ThreadState *thr, uptr pc, uptr addr) {
  444 void ReleaseStore(ThreadState *thr, uptr pc, uptr addr) {
  458   ThreadState *thr = reinterpret_cast<ThreadState*>(arg);
  466 void AfterSleep(ThreadState *thr, uptr pc) {
  477 void AcquireImpl(ThreadState *thr, uptr pc, SyncClock *c) {
  485 void ReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) {
  494 void ReleaseStoreImpl(ThreadState *thr, uptr pc, SyncClock *c) {
  503 void AcquireReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) {
  513 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) {

   46 void ProcWire(Processor *proc, ThreadState *thr) {
   53 void ProcUnwire(Processor *proc, ThreadState *thr) {

  236   ThreadState *thr = tctx->thr;
  249   ThreadState *thr = tctx->thr;
  442 static bool HandleRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2],
  488 static void AddRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2],
  503 bool OutputReport(ThreadState *thr, const ScopedReport &srep) {
  576 static bool RaceBetweenAtomicAndFree(ThreadState *thr) {
  589 void ReportRace(ThreadState *thr) {
  717 void PrintCurrentStack(ThreadState *thr, uptr pc) {

   42   ThreadState *caller_thr = static_cast<ThreadState *>(arg);
   48   ThreadState *thr;
   76   ThreadState *thr1 = static_cast<ThreadState*>(arg);
   81   ThreadState *thr;
   95   new(thr) ThreadState(ctx, tid, unique_id, epoch0, reuse_count,
  195 static void ThreadCheckIgnore(ThreadState *thr) {
  207 void ThreadFinalize(ThreadState *thr) {
  225 int ThreadCount(ThreadState *thr) {
  231 int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
  242 void ThreadStart(ThreadState *thr, int tid, tid_t os_id,
  277 void ThreadFinish(ThreadState *thr) {
  297 int ThreadTid(ThreadState *thr, uptr pc, uptr uid) {
  303 void ThreadJoin(ThreadState *thr, uptr pc, int tid) {
  310 void ThreadDetach(ThreadState *thr, uptr pc, int tid) {
  316 void ThreadNotJoined(ThreadState *thr, uptr pc, int tid, uptr uid) {
  322 void ThreadSetName(ThreadState *thr, const char *name) {
  326 void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
  409 void FiberSwitchImpl(ThreadState *from, ThreadState *to) {
  409 void FiberSwitchImpl(ThreadState *from, ThreadState *to) {
  416 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags) {
  416 ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags) {
  417   void *mem = internal_alloc(MBlockThreadContex, sizeof(ThreadState));
  418   ThreadState *fiber = static_cast<ThreadState *>(mem);
  427 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber) {
  427 void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber) {
  434 void FiberSwitch(ThreadState *thr, uptr pc,
  435                  ThreadState *fiber, unsigned flags) {

   25   ThreadState *thr = cur_thread();
   32   ThreadState *thr = cur_thread();

   19 void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s);
   26 void SyncVar::Init(ThreadState *thr, uptr pc, uptr addr, u64 uid) {
   61 void MetaMap::AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz) {
  196 SyncVar* MetaMap::GetOrCreateAndLock(ThreadState *thr, uptr pc,
  205 SyncVar* MetaMap::GetAndLock(ThreadState *thr, uptr pc,

   70   void Init(ThreadState *thr, uptr pc, uptr addr, u64 uid);
  115   void AllocBlock(ThreadState *thr, uptr pc, uptr p, uptr sz);
  121   SyncVar* GetOrCreateAndLock(ThreadState *thr, uptr pc,
  139   SyncVar* GetAndLock(ThreadState *thr, uptr pc, uptr addr, bool write_lock,