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

References

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  126   mutable std::mutex CODLayerMutex;
include/llvm/ExecutionEngine/Orc/IRCompileLayer.h
   46   mutable std::mutex IRLayerMutex;
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
   90     std::lock_guard<std::mutex> Lock(LTPMutex);
  103     std::lock_guard<std::mutex> Lock(LTPMutex);
  178   std::mutex LTPMutex;
  212   std::mutex CCMgrMutex;
  297     std::lock_guard<std::mutex> Lock(StubsMutex);
  307     std::lock_guard<std::mutex> Lock(StubsMutex);
  319     std::lock_guard<std::mutex> Lock(StubsMutex);
  335     std::lock_guard<std::mutex> Lock(StubsMutex);
  350     std::lock_guard<std::mutex> Lock(StubsMutex);
  386   std::mutex StubsMutex;
include/llvm/ExecutionEngine/Orc/LazyReexports.h
  102   std::mutex LCTMMutex;
include/llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h
   96     std::lock_guard<std::mutex> Lock(LayerMutex);
  147   mutable std::mutex LayerMutex;
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
  457       std::lock_guard<std::mutex> Lock(RTPMutex);
  484     std::mutex RTPMutex;
include/llvm/ExecutionEngine/Orc/RPCUtils.h
  827     std::lock_guard<std::mutex> Lock(SeqNoLock);
  835     std::lock_guard<std::mutex> Lock(SeqNoLock);
  845     std::lock_guard<std::mutex> Lock(SeqNoLock);
  850   std::mutex SeqNoLock;
 1033       std::lock_guard<std::mutex> Lock(ResponsesMutex);
 1124     std::lock_guard<std::mutex> Lock(ResponsesMutex);
 1192       std::unique_lock<std::mutex> Lock(ResponsesMutex);
 1347   std::mutex ResponsesMutex;
 1591       std::unique_lock<std::mutex> Lock(M);
 1601       std::unique_lock<std::mutex> Lock(M);
 1613     std::unique_lock<std::mutex> Lock(M);
 1619   std::mutex M;
include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h
  126   mutable std::mutex RTDyldLayerMutex;
include/llvm/ExecutionEngine/Orc/RawByteChannel.h
   78   std::mutex &getReadLock() { return readLock; }
   81   std::mutex &getWriteLock() { return writeLock; }
   84   std::mutex readLock, writeLock;
include/llvm/ExecutionEngine/Orc/Speculation.h
   52     std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
   60   std::mutex ConcurrentAccess;
   74     std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
   83       std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
  163   std::mutex ConcurrentAccess;
include/llvm/ExecutionEngine/Orc/SymbolStringPool.h
   45   mutable std::mutex PoolMutex;
  151   std::lock_guard<std::mutex> Lock(PoolMutex);
  159   std::lock_guard<std::mutex> Lock(PoolMutex);
  168   std::lock_guard<std::mutex> Lock(PoolMutex);
include/llvm/IR/ValueMap.h
   58   using mutex_type = MutexT;
include/llvm/Support/FileCollector.h
   59   std::mutex Mutex;
include/llvm/Support/ManagedStatic.h
   23   static void *call() { return new C(); }
   86   C &operator*() {
   94   C *operator->() { return &**this; }
   96   const C &operator*() const {
  104   const C *operator->() const { return &**this; }
include/llvm/Support/Parallel.h
   42   mutable std::mutex Mutex;
   50     std::lock_guard<std::mutex> lock(Mutex);
   55     std::lock_guard<std::mutex> lock(Mutex);
   61     std::unique_lock<std::mutex> lock(Mutex);
include/llvm/Support/TaskQueue.h
   90       std::lock_guard<std::mutex> Lock(QueueLock);
  111       std::lock_guard<std::mutex> Lock(QueueLock);
  131   std::mutex QueueLock;
include/llvm/Support/ThreadPool.h
   83   std::mutex QueueLock;
   87   std::mutex CompletionLock;
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
   97   mutable std::mutex SourceModuleMutex;
lib/ExecutionEngine/Orc/IRCompileLayer.cpp
   19   std::lock_guard<std::mutex> Lock(IRLayerMutex);
   29       std::lock_guard<std::mutex> Lock(IRLayerMutex);
lib/ExecutionEngine/Orc/IndirectionUtils.cpp
   67     std::lock_guard<std::mutex> Lock(CCMgrMutex);
   83     std::unique_lock<std::mutex> Lock(CCMgrMutex);
lib/ExecutionEngine/Orc/LazyReexports.cpp
   29   std::lock_guard<std::mutex> Lock(LCTMMutex);
   46     std::lock_guard<std::mutex> Lock(LCTMMutex);
   65     std::lock_guard<std::mutex> Lock(LCTMMutex);
lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
  358     std::lock_guard<std::mutex> Lock(LayerMutex);
  374     std::lock_guard<std::mutex> Lock(LayerMutex);
  394     std::lock_guard<std::mutex> Lock(LayerMutex);
lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp
  129     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
lib/ExecutionEngine/Orc/Speculation.cpp
   30   std::lock_guard<std::mutex> Lockit(ConcurrentAccess);
lib/LTO/LTO.cpp
 1059   std::mutex ErrMu;
 1138             std::unique_lock<std::mutex> L(ErrMu);
lib/Support/CrashRecoveryContext.cpp
   74 static ManagedStatic<std::mutex> gCrashRecoveryContextMutex;
  119   std::lock_guard<std::mutex> L(*gCrashRecoveryContextMutex);
  128   std::lock_guard<std::mutex> L(*gCrashRecoveryContextMutex);
lib/Support/ErrorHandling.cpp
   59 static std::mutex ErrorHandlerMutex;
   60 static std::mutex BadAllocErrorHandlerMutex;
   66   std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
   75   std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
  100     std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
  131   std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
  140   std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
  153     std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
lib/Support/FileCollector.cpp
   65   std::lock_guard<std::mutex> lock(Mutex);
  175   std::lock_guard<std::mutex> lock(Mutex);
lib/Support/Parallel.cpp
   52     std::unique_lock<std::mutex> Lock(Mutex);
   60     std::unique_lock<std::mutex> Lock(Mutex);
   69       std::unique_lock<std::mutex> Lock(Mutex);
   83   std::mutex Mutex;
lib/Support/ThreadPool.cpp
   36           std::unique_lock<std::mutex> LockGuard(QueueLock);
   49             std::unique_lock<std::mutex> LockGuard(CompletionLock);
   60           std::unique_lock<std::mutex> LockGuard(CompletionLock);
   73   std::unique_lock<std::mutex> LockGuard(CompletionLock);
   87     std::unique_lock<std::mutex> LockGuard(QueueLock);
  101     std::unique_lock<std::mutex> LockGuard(QueueLock);
lib/Support/Unix/Process.inc
  329 static ManagedStatic<std::mutex> TermColorMutex;
  335   std::lock_guard<std::mutex> G(*TermColorMutex);
lib/Transforms/Instrumentation/InstrOrderFile.cpp
   54 std::mutex MappingMutex;
  101       std::lock_guard<std::mutex> LogLock(MappingMutex);
projects/openmp/libomptarget/src/device.h
   97   std::mutex DataMapMtx, PendingGlobalsMtx, ShadowMtx;
projects/openmp/libomptarget/src/interface.cpp
   26 std::mutex TargetOffloadMtx;
projects/openmp/libomptarget/src/rtl.cpp
   32 std::mutex RTLsMtx;
   35 std::mutex TrlTblMtx;
   38 std::mutex TblMapMtx;
projects/openmp/libomptarget/src/rtl.h
   72   std::mutex Mtx;
  138 extern std::mutex RTLsMtx;
  157 extern std::mutex TrlTblMtx;
  169 extern std::mutex TblMapMtx;
tools/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h
  113     std::mutex ValueLock;
  127     std::mutex CacheLock;
tools/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp
   84   std::mutex Mtx;
   92       std::unique_lock<std::mutex> L(Mtx);
  101     std::unique_lock<std::mutex> L(Mtx);
tools/clang/lib/Frontend/PrecompiledPreamble.cpp
   98   std::mutex Mutex;
  108   std::lock_guard<std::mutex> Guard(Mutex);
  114   std::lock_guard<std::mutex> Guard(Mutex);
  121   std::lock_guard<std::mutex> Guard(Mutex);
tools/clang/lib/Tooling/AllTUsExecution.cpp
   36     std::unique_lock<std::mutex> LockGuard(Mutex);
   52   std::mutex Mutex;
   89   std::mutex TUMutex;
   91     std::unique_lock<std::mutex> LockGuard(TUMutex);
   96     std::unique_lock<std::mutex> LockGuard(TUMutex);
  110     std::unique_lock<std::mutex> LockGuard(TUMutex);
tools/clang/lib/Tooling/DependencyScanning/DependencyScanningFilesystem.cpp
  120   std::unique_lock<std::mutex> LockGuard(Shard.CacheLock);
  167     std::unique_lock<std::mutex> LockGuard(SharedCacheEntry.ValueLock);
tools/clang/tools/clang-scan-deps/ClangScanDeps.cpp
   32     std::unique_lock<std::mutex> LockGuard(Lock);
   38   std::mutex Lock;
  218   std::mutex Lock;
  233           std::unique_lock<std::mutex> LockGuard(Lock);
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/tool/FindAllSymbolsMain.cpp
   81   std::mutex SymbolMutex;
   84     std::unique_lock<std::mutex> LockGuard(SymbolMutex);
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp
  206       std::lock_guard<std::mutex> Mutex(CallMutex);
  263       std::lock_guard<std::mutex> Mutex(CallMutex);
  360         std::lock_guard<std::mutex> Lock(Server->TranspWriter);
  367         std::lock_guard<std::mutex> Lock(Server->TranspWriter);
  379   mutable std::mutex RequestCancelersMutex;
  391     std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
  412       std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
  419       std::lock_guard<std::mutex> Lock(RequestCancelersMutex);
  433   mutable std::mutex CallMutex;
  448   std::lock_guard<std::mutex> Lock(TranspWriter);
  454   std::lock_guard<std::mutex> Lock(TranspWriter);
  781     std::lock_guard<std::mutex> Lock(FixItsMutex);
  785     std::lock_guard<std::mutex> HLock(HighlightingsMutex);
 1253   std::lock_guard<std::mutex> Lock(FixItsMutex);
 1306     std::lock_guard<std::mutex> Lock(HighlightingsMutex);
 1334     std::lock_guard<std::mutex> Lock(FixItsMutex);
tools/clang/tools/extra/clangd/ClangdLSPServer.h
  149   std::mutex FixItsMutex;
  154   std::mutex HighlightingsMutex;
  162   std::mutex TranspWriter;
tools/clang/tools/extra/clangd/ClangdServer.cpp
  210           std::lock_guard<std::mutex> Lock(
  227       std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex);
tools/clang/tools/extra/clangd/ClangdServer.h
  334   mutable std::mutex CachedCompletionFuzzyFindRequestMutex;
tools/clang/tools/extra/clangd/DraftStore.cpp
   17   std::lock_guard<std::mutex> Lock(Mutex);
   27   std::lock_guard<std::mutex> Lock(Mutex);
   37   std::lock_guard<std::mutex> Lock(Mutex);
   44   std::lock_guard<std::mutex> Lock(Mutex);
  112   std::lock_guard<std::mutex> Lock(Mutex);
tools/clang/tools/extra/clangd/DraftStore.h
   52   mutable std::mutex Mutex;
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.cpp
  167     std::lock_guard<std::mutex> Lock(Mutex);
  218     std::lock_guard<std::mutex> Lock(Mutex);
  280     std::lock_guard<std::mutex> Lock(Mutex);
  296   std::lock_guard<std::mutex> Lock(Mutex);
  310     std::unique_lock<std::mutex> Lock(Mutex);
  321     std::lock_guard<std::mutex> Lock(Mutex);
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.h
  105   mutable std::mutex Mutex;
  142   mutable std::mutex Mutex;
tools/clang/tools/extra/clangd/Logger.cpp
   35     static std::mutex Mu;
   36     std::lock_guard<std::mutex> Guard(Mu);
   55   std::lock_guard<std::mutex> Guard(StreamMutex);
tools/clang/tools/extra/clangd/Logger.h
  102   std::mutex StreamMutex;
tools/clang/tools/extra/clangd/QueryDriverDatabase.cpp
  244       std::lock_guard<std::mutex> Lock(Mu);
  262   mutable std::mutex Mu;
tools/clang/tools/extra/clangd/TUScheduler.cpp
   96     std::lock_guard<std::mutex> Lock(Mut);
  106     std::unique_lock<std::mutex> Lock(Mut);
  124     std::unique_lock<std::mutex> Lock(Mut);
  143   std::mutex Mut;
  260   mutable std::mutex Mutex;
  274   std::mutex PublishMu;
  363   std::lock_guard<std::mutex> Lock(Mutex);
  375       std::lock_guard<std::mutex> Lock(PublishMu);
  399       std::lock_guard<std::mutex> Lock(Mutex);
  442       std::lock_guard<std::mutex> Lock(Mutex);
  478       std::lock_guard<std::mutex> Lock(PublishMu);
  562   std::lock_guard<std::mutex> Lock(Mutex);
  571   std::unique_lock<std::mutex> Lock(Mutex);
  595   std::unique_lock<std::mutex> Lock(Mutex);
  600   std::unique_lock<std::mutex> Lock(Mutex);
  618     std::lock_guard<std::mutex> Lock(PublishMu);
  622     std::lock_guard<std::mutex> Lock(Mutex);
  640     std::lock_guard<std::mutex> Lock(Mutex);
  654   std::lock_guard<std::mutex> Lock(PublishMu);
  665       std::unique_lock<std::mutex> Lock(Mutex);
  711       std::lock_guard<std::mutex> Lock(Mutex);
  789   std::unique_lock<std::mutex> Lock(Mutex);
tools/clang/tools/extra/clangd/Threading.cpp
   21     std::lock_guard<std::mutex> Lock(Mu);
   28   std::unique_lock<std::mutex> Lock(Mu);
   35   std::unique_lock<std::mutex> Lock(Mutex);
   48     std::unique_lock<std::mutex> Lock(Mutex);
   55   std::unique_lock<std::mutex> Lock(Mutex);
   65   std::unique_lock<std::mutex> Lock(Mutex);
   73     std::lock_guard<std::mutex> Lock(Mutex);
   78     std::lock_guard<std::mutex> Lock(Mutex);
  107 void wait(std::unique_lock<std::mutex> &Lock, std::condition_variable &CV,
tools/clang/tools/extra/clangd/Threading.h
   37   mutable std::mutex Mu;
   50   std::mutex Mutex;
   88 void wait(std::unique_lock<std::mutex> &Lock, std::condition_variable &CV,
   92 LLVM_NODISCARD bool wait(std::unique_lock<std::mutex> &Lock,
  116   mutable std::mutex Mutex;
tools/clang/tools/extra/clangd/Trace.cpp
   77     std::lock_guard<std::mutex> Lock(Mu);
  163     std::lock_guard<std::mutex> Lock(Mu);
  182   std::mutex Mu;
tools/clang/tools/extra/clangd/index/Background.cpp
  323       std::lock_guard<std::mutex> Lock(ShardVersionsMu);
  357     std::lock_guard<std::mutex> Lock(ShardVersionsMu);
  457     std::lock_guard<std::mutex> Lock(ShardVersionsMu);
tools/clang/tools/extra/clangd/index/Background.h
  103   std::mutex Mu;
  175   std::mutex ShardVersionsMu;
tools/clang/tools/extra/clangd/index/BackgroundIndexStorage.cpp
  107       : IndexStorageMapMu(std::make_unique<std::mutex>()),
  116     std::lock_guard<std::mutex> Lock(*IndexStorageMapMu);
  138   std::unique_ptr<std::mutex> IndexStorageMapMu;
tools/clang/tools/extra/clangd/index/BackgroundQueue.cpp
   24       std::unique_lock<std::mutex> Lock(Mu);
   45       std::unique_lock<std::mutex> Lock(Mu);
   61     std::lock_guard<std::mutex> QueueLock(Mu);
   69     std::lock_guard<std::mutex> Lock(Mu);
   79     std::lock_guard<std::mutex> Lock(Mu);
   89   std::lock_guard<std::mutex> Lock(Mu);
  109   std::unique_lock<std::mutex> Lock(Mu);
tools/clang/tools/extra/clangd/index/BackgroundRebuild.cpp
   79   std::lock_guard<std::mutex> Lock(Mu);
   85   std::lock_guard<std::mutex> Lock(Mu);
  101   std::lock_guard<std::mutex> Lock(Mu);
  109     std::lock_guard<std::mutex> Lock(Mu);
  124       std::lock_guard<std::mutex> Lock(Mu);
tools/clang/tools/extra/clangd/index/BackgroundRebuild.h
   83   std::mutex Mu;
tools/clang/tools/extra/clangd/index/FileIndex.cpp
   99   std::lock_guard<std::mutex> Lock(Mutex);
  125     std::lock_guard<std::mutex> Lock(Mutex);
tools/clang/tools/extra/clangd/index/FileIndex.h
   82   mutable std::mutex Mutex;
tools/clang/tools/extra/clangd/index/Index.cpp
   24     std::lock_guard<std::mutex> Lock(Mutex);
   30   std::lock_guard<std::mutex> Lock(Mutex);
tools/clang/tools/extra/clangd/index/Index.h
  149   mutable std::mutex Mutex;
tools/clang/tools/extra/clangd/indexer/IndexerMain.cpp
   49           std::lock_guard<std::mutex> Lock(SymbolsMu);
   58           std::lock_guard<std::mutex> Lock(SymbolsMu);
   66           std::lock_guard<std::mutex> Lock(SymbolsMu);
   84   std::mutex SymbolsMu;
tools/clang/tools/extra/clangd/tool/ClangdMain.cpp
  638   std::mutex ClangTidyOptMu;
  651       std::lock_guard<std::mutex> Lock(ClangTidyOptMu);
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp
   49   mutable std::mutex StorageMu;
   58     std::lock_guard<std::mutex> Lock(StorageMu);
   65     std::lock_guard<std::mutex> Lock(StorageMu);
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp
   67     std::lock_guard<std::mutex> Lock(Mutex);
   72     std::lock_guard<std::mutex> Lock(Mutex);
   77   std::mutex Mutex;
   89     std::lock_guard<std::mutex> Lock(Mutex);
   98     std::lock_guard<std::mutex> Lock(Mutex);
  105     std::lock_guard<std::mutex> Lock(Mutex);
  110   mutable std::mutex Mutex;
  605       std::lock_guard<std::mutex> Lock(Mutex);
  614       std::lock_guard<std::mutex> Lock(Mutex);
  619     std::mutex Mutex;
  778       std::unique_lock<std::mutex> Lock(Mutex, std::try_to_lock_t());
  793     std::mutex Mutex;
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp
 1160     std::unique_lock<std::mutex> Lock(Mut);
 1181     std::unique_lock<std::mutex> Lock(Mut);
 1192   mutable std::mutex Mut;
tools/clang/tools/extra/clangd/unittests/TUSchedulerTests.cpp
  368   std::mutex Mut;
  412                 std::lock_guard<std::mutex> Lock(Mut);
  429                 std::lock_guard<std::mutex> Lock(Mut);
  446                 std::lock_guard<std::mutex> Lock(Mut);
  456   std::lock_guard<std::mutex> Lock(Mut);
  575   std::mutex PreamblesMut;
  582           std::lock_guard<std::mutex> Lock(PreamblesMut);
  588   std::lock_guard<std::mutex> Lock(PreamblesMut);
  709       std::lock_guard<std::mutex> Lock(Mutex);
  714       std::lock_guard<std::mutex> Lock(Mutex);
  719     std::mutex Mutex;
tools/clang/tools/extra/clangd/unittests/ThreadingTests.cpp
   25   std::mutex Mutex;
   33             std::lock_guard<std::mutex> Lock(Mutex);
   43       std::lock_guard<std::mutex> Lock(Mutex);
   49       std::lock_guard<std::mutex> Lock(Mutex);
   54       std::lock_guard<std::mutex> Lock(Mutex);
   60   std::lock_guard<std::mutex> Lock(Mutex);
tools/clang/tools/libclang/CIndex.cpp
 8972 static llvm::ManagedStatic<std::mutex> LoggingMutex;
 8975   std::lock_guard<std::mutex> L(*LoggingMutex);
tools/clang/tools/libclang/Indexing.cpp
  126   mutable std::mutex Mutex;
  133     std::lock_guard<std::mutex> MG(Mutex);
  138     std::lock_guard<std::mutex> MG(Mutex);
tools/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp
  108   std::mutex Mtx;
  128     std::unique_lock<std::mutex> L(Mtx);
  142     std::unique_lock<std::mutex> L(Mtx);
  181     std::unique_lock<std::mutex> L(Mtx);
  249   std::unique_lock<std::mutex> L(TestConsumer.Mtx);
tools/dsymutil/BinaryHolder.cpp
  157     std::lock_guard<std::mutex> Lock(MemberCacheMutex);
  206   std::lock_guard<std::mutex> Lock(MemberCacheMutex);
  220     std::lock_guard<std::mutex> Lock(ArchiveCacheMutex);
  240   std::lock_guard<std::mutex> Lock(ObjectCacheMutex);
  254   std::lock_guard<std::mutex> ArchiveLock(ArchiveCacheMutex);
  255   std::lock_guard<std::mutex> ObjectLock(ObjectCacheMutex);
tools/dsymutil/BinaryHolder.h
  117     std::mutex MemberCacheMutex;
  129   std::mutex ArchiveCacheMutex;
  133   std::mutex ObjectCacheMutex;
tools/dsymutil/DwarfLinker.cpp
 2691   std::mutex ProcessedFilesMutex;
 2809       std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
 2818         std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
tools/lld/Common/ErrorHandler.cpp
   30 static std::mutex mu;
  151   std::lock_guard<std::mutex> lock(mu);
  156   std::lock_guard<std::mutex> lock(mu);
  167   std::lock_guard<std::mutex> lock(mu);
  190   std::lock_guard<std::mutex> lock(mu);
tools/lld/Common/Filesystem.cpp
   62   std::mutex m;
   67       std::lock_guard<std::mutex> l(m);
   76   std::unique_lock<std::mutex> l(m);
tools/lld/ELF/InputSection.cpp
  148     static std::mutex mu;
  149     std::lock_guard<std::mutex> lock(mu);
tools/lld/include/lld/Core/File.h
  239   std::mutex _parseMutex;
tools/lld/include/lld/ReaderWriter/MachOLinkingContext.h
  494   mutable std::mutex _dylibsMutex;
tools/lld/lib/Core/File.cpp
   22   std::lock_guard<std::mutex> lock(_parseMutex);
tools/lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp
  768   std::lock_guard<std::mutex> lock(_dylibsMutex);
tools/lldb/include/lldb/Breakpoint/BreakpointLocation.h
  339   std::mutex m_condition_mutex; ///< Guards parsing and evaluation of the
tools/lldb/include/lldb/Breakpoint/BreakpointLocationCollection.h
  171   mutable std::mutex m_collection_mutex;
tools/lldb/include/lldb/Core/Communication.h
  311   std::mutex
  313   std::mutex m_synchronize_mutex;
tools/lldb/include/lldb/Core/Debugger.h
  359   std::mutex m_output_flush_mutex;
tools/lldb/include/lldb/Core/ThreadSafeDenseMap.h
   30     std::lock_guard<_MutexType> guard(m_mutex);
   35     std::lock_guard<_MutexType> guard(m_mutex);
   40     std::lock_guard<_MutexType> guard(m_mutex);
   60   _MutexType m_mutex;
tools/lldb/include/lldb/Host/Editline.h
  359   std::mutex m_output_mutex;
tools/lldb/include/lldb/Host/File.h
  432   std::mutex offset_access_mutex;
tools/lldb/include/lldb/Host/OptionParser.h
   37   static void Prepare(std::unique_lock<std::mutex> &lock);
tools/lldb/include/lldb/Symbol/CompactUnwindInfo.h
  150   std::mutex m_mutex;
tools/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h
  155   std::mutex m_fde_index_mutex; // and isolate the thread that does it
tools/lldb/include/lldb/Symbol/TypeSystem.h
  524   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
tools/lldb/include/lldb/Symbol/UnwindTable.h
   74   std::mutex m_mutex;
tools/lldb/include/lldb/Target/Platform.h
  851   std::mutex m_mutex;
tools/lldb/include/lldb/Target/Process.h
 2670   std::mutex m_exit_status_mutex; ///< Mutex so m_exit_status m_exit_string can
 2749   std::mutex m_run_thread_plan_lock;
tools/lldb/include/lldb/Target/QueueList.h
   52                                  std::mutex>
   94   std::mutex &GetMutex();
  102   std::mutex m_mutex;
tools/lldb/include/lldb/Utility/Iterable.h
  173   LockingAdaptedIterable(C &container, MutexType &mutex)
  189   MutexType *m_mutex = nullptr;
tools/lldb/include/lldb/Utility/Listener.h
  118   FindNextEventInternal(std::unique_lock<std::mutex> &lock,
  134   std::mutex m_events_mutex; // Protects m_broadcasters and m_events
tools/lldb/include/lldb/Utility/Predicate.h
   72     std::lock_guard<std::mutex> guard(m_mutex);
   91     std::lock_guard<std::mutex> guard(m_mutex);
  123     std::unique_lock<std::mutex> lock(m_mutex);
  192   mutable std::mutex m_mutex; ///< The mutex to use when accessing the data
tools/lldb/include/lldb/Utility/Reproducer.h
  285   std::mutex m_providers_mutex;
  359   mutable std::mutex m_mutex;
tools/lldb/include/lldb/Utility/SharedCluster.h
   59     std::lock_guard<std::mutex> guard(m_mutex);
   65       std::lock_guard<std::mutex> guard(m_mutex);
   90   std::mutex m_mutex;
tools/lldb/include/lldb/Utility/UserIDResolver.h
   49   std::mutex m_mutex;
tools/lldb/source/Breakpoint/BreakpointLocation.cpp
  233   std::lock_guard<std::mutex> guard(m_condition_mutex);
tools/lldb/source/Breakpoint/BreakpointLocationCollection.cpp
   27   std::lock_guard<std::mutex> guard(m_collection_mutex);
   36   std::lock_guard<std::mutex> guard(m_collection_mutex);
  102   std::lock_guard<std::mutex> guard(m_collection_mutex);
  112   std::lock_guard<std::mutex> guard(m_collection_mutex);
  138   std::lock_guard<std::mutex> guard(m_collection_mutex);
  150   std::lock_guard<std::mutex> guard(m_collection_mutex);
  167   std::lock_guard<std::mutex> guard(m_collection_mutex);
  182       std::lock_guard<std::mutex> lhs_guard(m_collection_mutex, std::adopt_lock);
  183       std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex, std::adopt_lock);
tools/lldb/source/Core/Communication.cpp
  175   std::lock_guard<std::mutex> guard(m_write_mutex);
  383   std::lock_guard<std::mutex> guard(m_synchronize_mutex);
tools/lldb/source/Core/Debugger.cpp
 1280   std::lock_guard<std::mutex> guard(m_output_flush_mutex);
tools/lldb/source/Core/PluginManager.cpp
  288 static std::mutex &GetArchitectureMutex() {
  289     static std::mutex g_architecture_mutex;
  301   std::lock_guard<std::mutex> guard(GetArchitectureMutex());
  307   std::lock_guard<std::mutex> guard(GetArchitectureMutex());
  321   std::lock_guard<std::mutex> guard(GetArchitectureMutex());
tools/lldb/source/Host/common/Editline.cpp
 1279   std::lock_guard<std::mutex> guard(m_output_mutex);
 1290   std::lock_guard<std::mutex> guard(m_output_mutex);
 1326   std::lock_guard<std::mutex> guard(m_output_mutex);
 1371   std::lock_guard<std::mutex> guard(m_output_mutex);
 1399   std::lock_guard<std::mutex> guard(m_output_mutex);
tools/lldb/source/Host/common/OptionParser.cpp
   17 void OptionParser::Prepare(std::unique_lock<std::mutex> &lock) {
   18   static std::mutex g_mutex;
tools/lldb/source/Host/common/TaskPool.cpp
   34   std::mutex m_tasks_mutex;
   62   std::unique_lock<std::mutex> lock(m_tasks_mutex);
   89     std::unique_lock<std::mutex> lock(pool->m_tasks_mutex);
tools/lldb/source/Interpreter/Options.cpp
  987   std::unique_lock<std::mutex> lock;
 1112   std::unique_lock<std::mutex> lock;
 1301   std::unique_lock<std::mutex> lock;
tools/lldb/source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h
   74   std::mutex m_mutex;
tools/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp
  598   std::lock_guard<std::mutex> locker(m_dynamic_type_map_mutex);
  608   std::lock_guard<std::mutex> locker(m_dynamic_type_map_mutex);
tools/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h
  103   std::mutex m_dynamic_type_map_mutex;
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
 1406   std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex);
 1710   std::lock_guard<std::mutex> guard(m_get_shared_cache_class_info_args_mutex);
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h
  321   std::mutex m_get_class_info_args_mutex;
  325   std::mutex m_get_shared_cache_class_info_args_mutex;
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp
  771     std::lock_guard<std::mutex> guard(m_impl_function_mutex);
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h
  148   std::mutex m_impl_function_mutex;
tools/lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
 1128   std::lock_guard<std::mutex> guard(m_mutex);
 1571     std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp
  144   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
tools/lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h
   62   std::mutex m_sdk_dir_mutex;
tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
   63   std::unique_lock<std::mutex> lock(m_framelist_mutex);
tools/lldb/source/Plugins/Process/Utility/HistoryThread.h
   78   mutable std::mutex m_framelist_mutex;
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp
   43     std::lock_guard<std::mutex> lock(m_mutex);
   56       std::lock_guard<std::mutex> lock(m_mutex);
  252   std::lock_guard<std::mutex> lock(m_mutex);
  303     std::unique_lock<std::mutex> lock(m_comm.m_mutex);
  317   std::unique_lock<std::mutex> lock(m_comm.m_mutex);
  349   std::unique_lock<std::mutex> lock(m_comm.m_mutex);
  382     std::unique_lock<std::mutex> lock(m_comm.m_mutex);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h
  103   std::mutex m_mutex;
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
  243   std::unique_lock<std::mutex> lock(m_packet_queue_mutex);
 1328         std::lock_guard<std::mutex> guard(m_packet_queue_mutex);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
  210   std::mutex m_packet_queue_mutex; // Mutex for accessing queue
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
 2904     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 2949     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 3281   std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h
   86   std::mutex m_saved_registers_mutex;
tools/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp
   71 static std::mutex &GetGlobalOptionsMapLock() {
   72   static std::mutex s_options_map_lock;
   80   std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock());
   92   std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock());
 1257     std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex);
 1604     std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex);
tools/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h
  112   std::mutex m_added_breakpoint_mutex;
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.cpp
  113   std::lock_guard<std::mutex> lock(m_sections_mutex);
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwp.h
   43   std::mutex m_sections_mutex;
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
  109     std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex,
  140     std::lock_guard<std::mutex> guard(m_get_item_info_function_mutex);
  295   std::lock_guard<std::mutex> guard(m_get_item_info_retbuffer_mutex);
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h
  104   std::mutex m_get_item_info_function_mutex;
  107   std::mutex m_get_item_info_retbuffer_mutex;
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp
  112     std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex,
  145     std::lock_guard<std::mutex> guard(m_get_pending_items_function_mutex);
  298   std::lock_guard<std::mutex> guard(m_get_pending_items_retbuffer_mutex);
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h
  109   std::mutex m_get_pending_items_function_mutex;
  112   std::mutex m_get_pending_items_retbuffer_mutex;
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp
  108     std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex,
  156     std::lock_guard<std::mutex> guard(m_get_queues_function_mutex);
  295   std::lock_guard<std::mutex> guard(m_get_queues_retbuffer_mutex);
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h
  101   std::mutex m_get_queues_function_mutex;
  104   std::mutex m_get_queues_retbuffer_mutex;
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp
  118     std::unique_lock<std::mutex> lock(m_get_thread_item_info_retbuffer_mutex,
  151     std::lock_guard<std::mutex> guard(m_get_thread_item_info_function_mutex);
  301   std::lock_guard<std::mutex> guard(m_get_thread_item_info_retbuffer_mutex);
tools/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h
  103   std::mutex m_get_thread_item_info_function_mutex;
  106   std::mutex m_get_thread_item_info_retbuffer_mutex;
tools/lldb/source/Symbol/ClangExternalASTSourceCommon.cpp
   22 static ASTSourceMap &GetSourceMap(std::unique_lock<std::mutex> &guard) {
   25   static std::mutex s_mutex;
   26   std::unique_lock<std::mutex> locked_guard(s_mutex);
   33   std::unique_lock<std::mutex> guard;
   48   std::unique_lock<std::mutex> guard;
   53   std::unique_lock<std::mutex> guard;
tools/lldb/source/Symbol/CompactUnwindInfo.cpp
  245   std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/source/Symbol/DWARFCallFrameInfo.cpp
  417   std::lock_guard<std::mutex> guard(m_fde_index_mutex);
tools/lldb/source/Symbol/TypeSystem.cpp
  185     std::lock_guard<std::mutex> guard(m_mutex);
  199     std::lock_guard<std::mutex> guard(m_mutex);
  206   std::lock_guard<std::mutex> guard(m_mutex);
  225   std::lock_guard<std::mutex> guard(m_mutex);
  294   std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/source/Symbol/UnwindTable.cpp
   43   std::lock_guard<std::mutex> guard(m_mutex);
  117   std::lock_guard<std::mutex> guard(m_mutex);
  163   std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/source/Target/Language.cpp
   42 static std::mutex &GetLanguagesMutex() {
   43   static std::mutex *g_mutex = nullptr;
   47     g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
   55   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
  112   std::lock_guard<std::mutex> guard(GetLanguagesMutex());
tools/lldb/source/Target/Platform.cpp
  449   std::lock_guard<std::mutex> guard(m_mutex);
 1491     std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/source/Target/Process.cpp
 1084   std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 1092   std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 1101   std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 4614   std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock);
tools/lldb/source/Target/QueueList.cpp
   22   std::lock_guard<std::mutex> guard(m_mutex);
   27   std::lock_guard<std::mutex> guard(m_mutex);
   36   std::lock_guard<std::mutex> guard(m_mutex);
   41   std::lock_guard<std::mutex> guard(m_mutex);
   69 std::mutex &QueueList::GetMutex() { return m_mutex; }
tools/lldb/source/Target/Target.cpp
 2486   static std::mutex s_clang_modules_decl_vendor_mutex; // If this is contended
 2491     std::lock_guard<std::mutex> guard(s_clang_modules_decl_vendor_mutex);
tools/lldb/source/Utility/Listener.cpp
   70   std::lock_guard<std::mutex> events_guard(m_events_mutex);
  176     std::lock_guard<std::mutex> events_guard(m_events_mutex);
  209   std::lock_guard<std::mutex> guard(m_events_mutex);
  264     std::unique_lock<std::mutex> &lock,
  319   std::unique_lock<std::mutex> guard(m_events_mutex);
  327   std::unique_lock<std::mutex> guard(m_events_mutex);
  337   std::unique_lock<std::mutex> guard(m_events_mutex);
  354   std::unique_lock<std::mutex> lock(m_events_mutex);
tools/lldb/source/Utility/Reproducer.cpp
   67   std::lock_guard<std::mutex> guard(m_mutex);
   74   std::lock_guard<std::mutex> guard(m_mutex);
   81   std::lock_guard<std::mutex> guard(m_mutex);
   88   std::lock_guard<std::mutex> guard(m_mutex);
   95   std::lock_guard<std::mutex> guard(m_mutex);
  112   std::lock_guard<std::mutex> guard(m_mutex);
  154   std::lock_guard<std::mutex> lock(m_providers_mutex);
tools/lldb/source/Utility/Timer.cpp
   32 static std::mutex &GetFileMutex() {
   33   static std::mutex *g_file_mutex_ptr = new std::mutex();
   33   static std::mutex *g_file_mutex_ptr = new std::mutex();
   60     std::lock_guard<std::mutex> lock(GetFileMutex());
   84     std::lock_guard<std::mutex> lock(GetFileMutex());
tools/lldb/source/Utility/UserIDResolver.cpp
   20   std::lock_guard<std::mutex> guard(m_mutex);
tools/lldb/tools/lldb-vscode/VSCode.cpp
  103   static std::mutex mutex;
  104   std::lock_guard<std::mutex> locker(mutex);
tools/llvm-cov/CodeCoverage.cpp
  152   std::mutex ErrsLock;
  155   std::mutex LoadedSourceFilesLock;
  175   std::unique_lock<std::mutex> Guard{ErrsLock};
  181   std::unique_lock<std::mutex> Guard{ErrsLock};
  233   std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
tools/llvm-cov/CoverageExporterJson.cpp
  162   std::mutex FileArrayMutex;
  170         std::lock_guard<std::mutex> Lock(FileArrayMutex);
tools/llvm-profdata/llvm-profdata.cpp
  185   std::mutex Lock;
  188   std::mutex &ErrLock;
  191   WriterContext(bool IsSparse, std::mutex &ErrLock,
  226   std::unique_lock<std::mutex> CtxGuard{WC->Lock};
  267       std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
  286     std::unique_lock<std::mutex> ErrGuard{Dst->ErrLock};
  305   std::mutex ErrorLock;
  700   std::mutex ErrorLock;
unittests/ExecutionEngine/Orc/QueueChannel.h
   52   std::mutex &getMutex() { return M; }
   58       std::lock_guard<std::mutex> Lock(M);
   64     std::lock_guard<std::mutex> Lock(M);
   68   std::mutex M;
  109     std::unique_lock<std::mutex> Lock(InQueue->getMutex());
  129     std::unique_lock<std::mutex> Lock(OutQueue->getMutex());
unittests/IR/ValueMapTest.cpp
  180 struct LockMutex : ValueMapConfig<KeyT, MutexT> {
  182     MutexT *M;
  194   static MutexT *getMutex(const ExtraData &Data) { return Data.M; }
  199   std::mutex M;
  201   typedef LockMutex<TypeParam*, std::mutex> ConfigType;
unittests/Support/TaskQueueTest.cpp
   31   std::mutex M1, M2, M3;
   32   std::unique_lock<std::mutex> L1(M1);
   33   std::unique_lock<std::mutex> L2(M2);
   34   std::unique_lock<std::mutex> L3(M3);
   37     std::unique_lock<std::mutex> Lock(M1);
   41     std::unique_lock<std::mutex> Lock(M2);
   45     std::unique_lock<std::mutex> Lock(M3);
   74   std::mutex M;
   76   std::unique_lock<std::mutex> Lock(M);
   81     std::unique_lock<std::mutex> Lock(M);
unittests/Support/ThreadPool.cpp
   57     std::unique_lock<std::mutex> LockGuard(WaitMainThreadMutex);
   64       std::unique_lock<std::mutex> LockGuard(WaitMainThreadMutex);
   73   std::mutex WaitMainThreadMutex;
unittests/Support/Threading.cpp
   33       std::lock_guard<std::mutex> Lock(M);
   40     std::unique_lock<std::mutex> Lock(M);
   51   mutable std::mutex M;
usr/include/c++/7.4.0/bits/alloc_traits.h
  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  486 	destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h
  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/move.h
   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   83     constexpr _Tp&&
usr/include/c++/7.4.0/bits/shared_ptr.h
   93     class shared_ptr : public __shared_ptr<_Tp>
  107       using element_type = typename __shared_ptr<_Tp>::element_type;
  236 	shared_ptr(const shared_ptr<_Yp>& __r) noexcept
  253 	shared_ptr(shared_ptr<_Yp>&& __r) noexcept
  352       shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
  520     class weak_ptr : public __weak_ptr<_Tp>
  582       shared_ptr<_Tp>
  687     inline shared_ptr<_Tp>
  702     inline shared_ptr<_Tp>
  705       typedef typename std::remove_const<_Tp>::type _Tp_nc;
  706       return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
usr/include/c++/7.4.0/bits/shared_ptr_base.h
  514 	__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
  559       _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
  629 	__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
  633 	  typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
  882     : is_convertible<_Yp*, _Tp*>::type
  882     : is_convertible<_Yp*, _Tp*>::type
  956       using element_type = _Tp;
 1035     : public __shared_ptr_access<_Tp, _Lp>
 1038       using element_type = typename remove_extent<_Tp>::type;
 1126 	__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 1138 	__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 1192 	_Assignable<_Yp>
 1193 	operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 1218 	_Assignable<_Yp>
 1219 	operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 1272       swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
 1321 	    rebind_traits<typename std::remove_cv<_Tp>::type> __traits;
 1344       __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
 1377 	typename enable_if<!__has_esft_base<_Yp2>::value>::type
 1378 	_M_enable_shared_from_this_with(_Yp*) noexcept
 1601       using element_type = typename remove_extent<_Tp>::type;
 1626 	__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 1640 	__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 1648 	_Assignable<_Yp>
 1649 	operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 1675 	_Assignable<_Yp>
 1676 	operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 1684       __shared_ptr<_Tp, _Lp>
 1720       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
usr/include/c++/7.4.0/bits/std_mutex.h
   97     mutex(const mutex&) = delete;
   98     mutex& operator=(const mutex&) = delete;
   98     mutex& operator=(const mutex&) = delete;
  159       typedef _Mutex mutex_type;
  188       typedef _Mutex mutex_type;
usr/include/c++/7.4.0/bits/unique_ptr.h
   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/condition_variable
   92     wait(unique_lock<mutex>& __lock) noexcept;
   96       wait(unique_lock<mutex>& __lock, _Predicate __p)
  104       wait_until(unique_lock<mutex>& __lock,
  110       wait_until(unique_lock<mutex>& __lock,
  124       wait_until(unique_lock<mutex>& __lock,
  136       wait_for(unique_lock<mutex>& __lock,
  148       wait_for(unique_lock<mutex>& __lock,
  166       __wait_until_impl(unique_lock<mutex>& __lock,
  187   notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
  203     shared_ptr<mutex>			_M_mutex;
  233     condition_variable_any() : _M_mutex(std::make_shared<mutex>()) { }
  242       lock_guard<mutex> __lock(*_M_mutex);
  249       lock_guard<mutex> __lock(*_M_mutex);
  257 	shared_ptr<mutex> __mutex = _M_mutex;
  258 	unique_lock<mutex> __my_lock(*__mutex);
  262 	unique_lock<mutex> __my_lock2(std::move(__my_lock));
  280 	shared_ptr<mutex> __mutex = _M_mutex;
  281 	unique_lock<mutex> __my_lock(*__mutex);
  285 	unique_lock<mutex> __my_lock2(std::move(__my_lock));
usr/include/c++/7.4.0/ext/aligned_buffer.h
   85     : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
   85     : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
   88 	std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
   88 	std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
  108       _Tp*
  112       const _Tp*
usr/include/c++/7.4.0/ext/new_allocator.h
   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
   84 	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/mutex
  468     inline unique_lock<_Lock>
  469     __try_to_lock(_Lock& __l)
  497 	__do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
  542     lock(_L1& __l1, _L2& __l2, _L3&... __l3)
  542     lock(_L1& __l1, _L2& __l2, _L3&... __l3)
  547           unique_lock<_L1> __first(__l1);
usr/include/c++/7.4.0/tuple
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  159       static constexpr _Head&
  162       static constexpr const _Head&
  350       static constexpr _Head&
  353       static constexpr const _Head&
  360       constexpr _Tuple_impl(const _Head& __head)
  365         constexpr _Tuple_impl(_UHead&& __head)
  390 		    const _Head& __head)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  646         constexpr tuple(_UElements&&... __elements)
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
 1302     constexpr _Head&
 1307     constexpr const _Head&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1588     constexpr tuple<_Elements&...>
 1589     tie(_Elements&... __args) noexcept
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1659     { typedef _Tp&&   type; };
 1942     { typedef _Tp     type; };
utils/benchmark/src/mutex.h
   81   std::mutex& native_handle() { return mut_; }
   84   std::mutex mut_;
   88   typedef std::unique_lock<std::mutex> MutexLockImp;