CbC/CbC_gcc: libsanitizer/tsan/tsan

comparison libsanitizer/tsan/tsan_rtl.h @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	04ced10e8804
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 //===-- tsan_rtl.h ----------------------------------------------*- C++ -*-===//
 //
-// This file is distributed under the University of Illinois Open Source
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// License. See LICENSE.TXT for details.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_deadlock_detector_interface.h"
 #include "sanitizer_common/sanitizer_libignore.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
+#include "sanitizer_common/sanitizer_vector.h"
 #include "tsan_clock.h"
 #include "tsan_defs.h"
 #include "tsan_flags.h"
+#include "tsan_mman.h"
 #include "tsan_sync.h"
 #include "tsan_trace.h"
-#include "tsan_vector.h"
 #include "tsan_report.h"
 #include "tsan_platform.h"
 #include "tsan_mutexset.h"
 #include "tsan_ignoreset.h"
 #include "tsan_stack_trace.h"
 namespace __tsan {
 #if !SANITIZER_GO
 struct MapUnmapCallback;
 #if defined(__mips64) || defined(__aarch64__) || defined(__powerpc__)
-static const uptr kAllocatorRegionSizeLog = 20;
-static const uptr kAllocatorNumRegions =
-SANITIZER_MMAP_RANGE_SIZE >> kAllocatorRegionSizeLog;
-typedef TwoLevelByteMap<(kAllocatorNumRegions >> 12), 1 << 12,
-MapUnmapCallback> ByteMap;
 struct AP32 {
 static const uptr kSpaceBeg = 0;
 static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
 static const uptr kMetadataSize = 0;
 typedef __sanitizer::CompactSizeClassMap SizeClassMap;
-static const uptr kRegionSizeLog = kAllocatorRegionSizeLog;
+static const uptr kRegionSizeLog = 20;
-typedef __tsan::ByteMap ByteMap;
+using AddressSpaceView = LocalAddressSpaceView;
 typedef __tsan::MapUnmapCallback MapUnmapCallback;
 static const uptr kFlags = 0;
 };
 typedef SizeClassAllocator32<AP32> PrimaryAllocator;
 #else
 static const uptr kSpaceSize = Mapping::kHeapMemEnd - Mapping::kHeapMemBeg;
 static const uptr kMetadataSize = 0;
 typedef DefaultSizeClassMap SizeClassMap;
 typedef __tsan::MapUnmapCallback MapUnmapCallback;
 static const uptr kFlags = 0;
+using AddressSpaceView = LocalAddressSpaceView;
 };
 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
 #endif
-typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef CombinedAllocator<PrimaryAllocator> Allocator;
-typedef LargeMmapAllocator<MapUnmapCallback> SecondaryAllocator;
+typedef Allocator::AllocatorCache AllocatorCache;
-typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
-SecondaryAllocator> Allocator;
 Allocator *allocator();
 #endif
 void TsanCheckFailed(const char *file, int line, const char *cond,
 u64 v1, u64 v2);
 static ALWAYS_INLINE bool TwoRangesIntersect(Shadow s1, Shadow s2,
 unsigned kS2AccessSize) {
 bool res = false;
 u64 diff = s1.addr0() - s2.addr0();
-if ((s64)diff < 0) {  // s1.addr0 < s2.addr0  // NOLINT
+if ((s64)diff < 0) {  // s1.addr0 < s2.addr0
 // if (s1.addr0() + size1) > s2.addr0()) return true;
 if (s1.size() > -diff)
 res = true;
 } else {
 // if (s2.addr0() + kS2AccessSize > s1.addr0()) return true;
 struct ThreadSignalContext;
 struct JmpBuf {
 uptr sp;
-uptr mangled_sp;
 int int_signal_send;
 bool in_blocking_func;
 uptr in_signal_handler;
 uptr *shadow_stack_pos;
 };
 // QUESTION: can we can squeeze this into ThreadState::Fast?
 // E.g. ThreadState::Fast is a 44-bit, 32 are taken by synch_epoch and 12 are
 // taken by epoch between synchs.
 // This way we can save one load from tls.
 u64 fast_synch_epoch;
+// Technically `current` should be a separate THREADLOCAL variable;
+// but it is placed here in order to share cache line with previous fields.
+ThreadState* current;
 // This is a slow path flag. On fast path, fast_state.GetIgnoreBit() is read.
 // We do not distinguish beteween ignoring reads and writes
 // for better performance.
 int ignore_reads_and_writes;
 int ignore_sync;
 };
 #if !SANITIZER_GO
 #if SANITIZER_MAC || SANITIZER_ANDROID
 ThreadState *cur_thread();
+void set_cur_thread(ThreadState *thr);
 void cur_thread_finalize();
+INLINE void cur_thread_init() { }
 #else
 __attribute__((tls_model("initial-exec")))
 extern THREADLOCAL char cur_thread_placeholder[];
 INLINE ThreadState *cur_thread() {
-return reinterpret_cast<ThreadState *>(&cur_thread_placeholder);
+return reinterpret_cast<ThreadState *>(cur_thread_placeholder)->current;
+}
+INLINE void cur_thread_init() {
+ThreadState *thr = reinterpret_cast<ThreadState *>(cur_thread_placeholder);
+if (UNLIKELY(!thr->current))
+thr->current = thr;
+}
+INLINE void set_cur_thread(ThreadState *thr) {
+reinterpret_cast<ThreadState *>(cur_thread_placeholder)->current = thr;
 }
 INLINE void cur_thread_finalize() { }
 #endif  // SANITIZER_MAC || SANITIZER_ANDROID
 #endif  // SANITIZER_GO
 struct Context {
 Context();
 bool initialized;
+#if !SANITIZER_GO
 bool after_multithreaded_fork;
+#endif
 MetaMap metamap;
 Mutex report_mtx;
 int nreported;
 const char *GetObjectTypeFromTag(uptr tag);
 const char *GetReportHeaderFromTag(uptr tag);
 uptr TagFromShadowStackFrame(uptr pc);
-class ScopedReport {
+class ScopedReportBase {
 public:
-explicit ScopedReport(ReportType typ, uptr tag = kExternalTagNone);
-~ScopedReport();
 void AddMemoryAccess(uptr addr, uptr external_tag, Shadow s, StackTrace stack,
 const MutexSet *mset);
 void AddStack(StackTrace stack, bool suppressable = false);
 void AddThread(const ThreadContext *tctx, bool suppressable = false);
 void AddThread(int unique_tid, bool suppressable = false);
 void AddSleep(u32 stack_id);
 void SetCount(int count);
 const ReportDesc *GetReport() const;
+protected:
+ScopedReportBase(ReportType typ, uptr tag);
+~ScopedReportBase();
 private:
 ReportDesc *rep_;
 // Symbolizer makes lots of intercepted calls. If we try to process them,
 // at best it will cause deadlocks on internal mutexes.
 ScopedIgnoreInterceptors ignore_interceptors_;
 void AddDeadMutex(u64 id);
-ScopedReport(const ScopedReport&);
+ScopedReportBase(const ScopedReportBase &) = delete;
-void operator = (const ScopedReport&);
+void operator=(const ScopedReportBase &) = delete;
+};
+class ScopedReport : public ScopedReportBase {
+public:
+explicit ScopedReport(ReportType typ, uptr tag = kExternalTagNone);
+~ScopedReport();
+private:
+ScopedErrorReportLock lock_;
 };
 ThreadContext *IsThreadStackOrTls(uptr addr, bool *is_stack);
 void RestoreStack(int tid, const u64 epoch, VarSizeStackTrace *stk,
 MutexSet *mset, uptr *tag = nullptr);
 }
 stack->Init(&thr->shadow_stack[start], size, toppc);
 ExtractTagFromStack(stack, tag);
 }
+#define GET_STACK_TRACE_FATAL(thr, pc) \
+VarSizeStackTrace stack; \
+ObtainCurrentStack(thr, pc, &stack); \
+stack.ReverseOrder();
 #if TSAN_COLLECT_STATS
 void StatAggregate(u64 *dst, u64 *src);
 void StatOutput(u64 *stat);
 #endif
 }
 void MapShadow(uptr addr, uptr size);
 void MapThreadTrace(uptr addr, uptr size, const char *name);
 void DontNeedShadowFor(uptr addr, uptr size);
+void UnmapShadow(ThreadState *thr, uptr addr, uptr size);
 void InitializeShadowMemory();
 void InitializeInterceptors();
 void InitializeLibIgnore();
 void InitializeDynamicAnnotations();
 ReportStack *SymbolizeStackId(u32 stack_id);
 void PrintCurrentStack(ThreadState *thr, uptr pc);
 void PrintCurrentStackSlow(uptr pc);  // uses libunwind
 void Initialize(ThreadState *thr);
+void MaybeSpawnBackgroundThread();
 int Finalize(ThreadState *thr);
 void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write);
 void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write);
 }
 void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size);
 void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size);
 void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size);
+void MemoryRangeImitateWriteOrResetRange(ThreadState *thr, uptr pc, uptr addr,
+uptr size);
 void ThreadIgnoreBegin(ThreadState *thr, uptr pc, bool save_stack = true);
 void ThreadIgnoreEnd(ThreadState *thr, uptr pc);
 void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc, bool save_stack = true);
 void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc);
 void FuncEntry(ThreadState *thr, uptr pc);
 void FuncExit(ThreadState *thr);
 int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached);
-void ThreadStart(ThreadState *thr, int tid, tid_t os_id, bool workerthread);
+void ThreadStart(ThreadState *thr, int tid, tid_t os_id,
+ThreadType thread_type);
 void ThreadFinish(ThreadState *thr);
 int ThreadTid(ThreadState *thr, uptr pc, uptr uid);
 void ThreadJoin(ThreadState *thr, uptr pc, int tid);
 void ThreadDetach(ThreadState *thr, uptr pc, int tid);
 void ThreadFinalize(ThreadState *thr);
 void ThreadSetName(ThreadState *thr, const char *name);
 int ThreadCount(ThreadState *thr);
 void ProcessPendingSignals(ThreadState *thr);
+void ThreadNotJoined(ThreadState *thr, uptr pc, int tid, uptr uid);
 Processor *ProcCreate();
 void ProcDestroy(Processor *proc);
 void ProcWire(Processor *proc, ThreadState *thr);
 void ProcUnwire(Processor *proc, ThreadState *thr);
 uptr ALWAYS_INLINE HeapEnd() {
 return HeapMemEnd() + PrimaryAllocator::AdditionalSize();
 }
 #endif
+ThreadState *FiberCreate(ThreadState *thr, uptr pc, unsigned flags);
+void FiberDestroy(ThreadState *thr, uptr pc, ThreadState *fiber);
+void FiberSwitch(ThreadState *thr, uptr pc, ThreadState *fiber, unsigned flags);
+// These need to match __tsan_switch_to_fiber_* flags defined in
+// tsan_interface.h. See documentation there as well.
+enum FiberSwitchFlags {
+FiberSwitchFlagNoSync = 1 << 0, // __tsan_switch_to_fiber_no_sync
+};
 }  // namespace __tsan
 #endif  // TSAN_RTL_H

Mercurial > hg > CbC > CbC_gcc

comparison libsanitizer/tsan/tsan_rtl.h @ 145:1830386684a0