1402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski//===- ThreadSafety.h ------------------------------------------*- C++ --*-===// 2402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 3402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// The LLVM Compiler Infrastructure 4402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 5402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// This file is distributed under the University of Illinois Open Source 6402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// License. See LICENSE.TXT for details. 7402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 8402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski//===----------------------------------------------------------------------===// 9402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 10402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 11402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// A intra-procedural analysis for thread safety (e.g. deadlocks and race 12402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// conditions), based off of an annotation system. 13402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 14eb7c6f3c49b4b3c2b01aeeed54bf5915fbf9b021Aaron Ballman// See http://clang.llvm.org/docs/LanguageExtensions.html#thread-safety-annotation-checking 15eb7c6f3c49b4b3c2b01aeeed54bf5915fbf9b021Aaron Ballman// for more information. 16402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 17402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski//===----------------------------------------------------------------------===// 18402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 19176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETY_H 20176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#define LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETY_H 21402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 22d5b16055782034ca90153880c36bd88b59c63aa0Caitlin Sadowski#include "clang/Analysis/AnalysisContext.h" 23402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "clang/Basic/SourceLocation.h" 24402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/StringRef.h" 25402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 26402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskinamespace clang { 27176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesnamespace threadSafety { 28402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 290e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesclass BeforeSet; 300e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 3119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// This enum distinguishes between different kinds of operations that may 3219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// need to be protected by locks. We use this enum in error handling. 33402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskienum ProtectedOperationKind { 34959dc8475fc20ce8c3fd55021cb9f02a531cddc5Dmitri Gribenko POK_VarDereference, ///< Dereferencing a variable (e.g. p in *p = 5;) 35959dc8475fc20ce8c3fd55021cb9f02a531cddc5Dmitri Gribenko POK_VarAccess, ///< Reading or writing a variable (e.g. x in x = 5;) 36176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines POK_FunctionCall, ///< Making a function call (e.g. fool()) 37176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines POK_PassByRef, ///< Passing a guarded variable by reference. 38176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines POK_PtPassByRef, ///< Passing a pt-guarded variable by reference. 39402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 40402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 4119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// This enum distinguishes between different kinds of lock actions. For 4219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// example, it is an error to write a variable protected by shared version of a 4319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// mutex. 44402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskienum LockKind { 45176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK_Shared, ///< Shared/reader lock of a mutex. 46651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines LK_Exclusive, ///< Exclusive/writer lock of a mutex. 47176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK_Generic ///< Can be either Shared or Exclusive 48402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 49402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 5019903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// This enum distinguishes between different ways to access (read or write) a 5119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// variable. 52402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskienum AccessKind { 53959dc8475fc20ce8c3fd55021cb9f02a531cddc5Dmitri Gribenko AK_Read, ///< Reading a variable. 54959dc8475fc20ce8c3fd55021cb9f02a531cddc5Dmitri Gribenko AK_Written ///< Writing a variable. 55402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 56402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 574e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// This enum distinguishes between different situations where we warn due to 584e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// inconsistent locking. 594e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// \enum SK_LockedSomeLoopIterations -- a mutex is locked for some but not all 604e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// loop iterations. 614e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// \enum SK_LockedSomePredecessors -- a mutex is locked in some but not all 624e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// predecessors of a CFGBlock. 634e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// \enum SK_LockedAtEndOfFunction -- a mutex is still locked at the end of a 644e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// function. 654e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowskienum LockErrorKind { 664e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski LEK_LockedSomeLoopIterations, 674e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski LEK_LockedSomePredecessors, 68879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins LEK_LockedAtEndOfFunction, 69879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins LEK_NotLockedAtEndOfFunction 704e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski}; 714e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski 7219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// Handler class for thread safety warnings. 73402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskiclass ThreadSafetyHandler { 74402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowskipublic: 75cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko typedef StringRef Name; 76fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins ThreadSafetyHandler() : IssueBetaWarnings(false) { } 779f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins virtual ~ThreadSafetyHandler(); 7819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 7919903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn about lock expressions which fail to resolve to lockable objects. 80651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 8119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param Loc -- the SourceLocation of the unresolved expression. 82651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleInvalidLockExp(StringRef Kind, SourceLocation Loc) {} 8319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 8419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn about unlock function calls that do not have a prior matching lock 8519903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// expression. 86651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 8719903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param LockName -- A StringRef name for the lock expression, to be printed 8819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// in the error message. 8919903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param Loc -- The SourceLocation of the Unlock 90651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleUnmatchedUnlock(StringRef Kind, Name LockName, 91651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SourceLocation Loc) {} 92651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 93651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// Warn about an unlock function call that attempts to unlock a lock with 94651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// the incorrect lock kind. For instance, a shared lock being unlocked 95651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// exclusively, or vice versa. 96651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param LockName -- A StringRef name for the lock expression, to be printed 97651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// in the error message. 98651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 99651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Expected -- the kind of lock expected. 100651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Received -- the kind of lock received. 101651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Loc -- The SourceLocation of the Unlock. 102651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleIncorrectUnlockKind(StringRef Kind, Name LockName, 103651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines LockKind Expected, LockKind Received, 104651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SourceLocation Loc) {} 10519903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 10619903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn about lock function calls for locks which are already held. 107651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 10819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param LockName -- A StringRef name for the lock expression, to be printed 10919903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// in the error message. 110b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc -- The location of the second lock expression. 111651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleDoubleLock(StringRef Kind, Name LockName, 112651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SourceLocation Loc) {} 11319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 11419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn about situations where a mutex is sometimes held and sometimes not. 1154e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski /// The three situations are: 1164e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski /// 1. a mutex is locked on an "if" branch but not the "else" branch, 1174e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski /// 2, or a mutex is only held at the start of some loop iterations, 1184e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski /// 3. or when a mutex is locked but not unlocked inside a function. 119651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 12019903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param LockName -- A StringRef name for the lock expression, to be printed 12119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// in the error message. 1222e5156274b8051217565b557bfa14c80f7990e9cRichard Smith /// \param LocLocked -- The location of the lock expression where the mutex is 123ba243b59a1074e0962f6abfa3bb9aa984eac1245David Blaikie /// locked 1242e5156274b8051217565b557bfa14c80f7990e9cRichard Smith /// \param LocEndOfScope -- The location of the end of the scope where the 1252e5156274b8051217565b557bfa14c80f7990e9cRichard Smith /// mutex is no longer held 1264e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski /// \param LEK -- which of the three above cases we should warn for 127651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleMutexHeldEndOfScope(StringRef Kind, Name LockName, 1282e5156274b8051217565b557bfa14c80f7990e9cRichard Smith SourceLocation LocLocked, 1292e5156274b8051217565b557bfa14c80f7990e9cRichard Smith SourceLocation LocEndOfScope, 130651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines LockErrorKind LEK) {} 13119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 13219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn when a mutex is held exclusively and shared at the same point. For 13319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// example, if a mutex is locked exclusively during an if branch and shared 13419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// during the else branch. 135651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 13619903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param LockName -- A StringRef name for the lock expression, to be printed 13719903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// in the error message. 138b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc1 -- The location of the first lock expression. 139b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc2 -- The location of the second lock expression. 140651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleExclusiveAndShared(StringRef Kind, Name LockName, 141651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SourceLocation Loc1, 142402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski SourceLocation Loc2) {} 14319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 14419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn when a protected operation occurs while no locks are held. 145651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 14619903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param D -- The decl for the protected variable or function 14719903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param POK -- The kind of protected operation (e.g. variable access) 14819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param AK -- The kind of access (i.e. read or write) that occurred 149b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc -- The location of the protected operation. 150651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleNoMutexHeld(StringRef Kind, const NamedDecl *D, 151651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ProtectedOperationKind POK, AccessKind AK, 152651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines SourceLocation Loc) {} 15319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 15419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn when a protected operation occurs while the specific mutex protecting 15519903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// the operation is not locked. 156651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 15719903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param D -- The decl for the protected variable or function 15819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param POK -- The kind of protected operation (e.g. variable access) 159edd6d40770c9010883307b195acea6e9d732263aJames Dennett /// \param LockName -- A StringRef name for the lock expression, to be printed 160edd6d40770c9010883307b195acea6e9d732263aJames Dennett /// in the error message. 161edd6d40770c9010883307b195acea6e9d732263aJames Dennett /// \param LK -- The kind of access (i.e. read or write) that occurred 162b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc -- The location of the protected operation. 163651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleMutexNotHeld(StringRef Kind, const NamedDecl *D, 164402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski ProtectedOperationKind POK, Name LockName, 1653f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins LockKind LK, SourceLocation Loc, 1666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Name *PossibleMatch = nullptr) {} 16719903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 168176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// Warn when acquiring a lock that the negative capability is not held. 169176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 170176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// \param LockName -- The name for the lock expression, to be printed in the 171176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// diagnostic. 172176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// \param Neg -- The name of the negative capability to be printed in the 173176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// diagnostic. 174176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// \param Loc -- The location of the protected operation. 175176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual void handleNegativeNotHeld(StringRef Kind, Name LockName, Name Neg, 176176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation Loc) {} 177176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 17819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// Warn when a function is called while an excluded mutex is locked. For 17919903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// example, the mutex may be locked inside the function. 180651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \param Kind -- the capability's name parameter (role, mutex, etc). 18119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param FunName -- The name of the function 18219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// \param LockName -- A StringRef name for the lock expression, to be printed 18319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski /// in the error message. 184b50dd472cd6c8b13213626f13a928dbe41581f09Caitlin Sadowski /// \param Loc -- The location of the function call. 185651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines virtual void handleFunExcludesLock(StringRef Kind, Name FunName, 186651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Name LockName, SourceLocation Loc) {} 187fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins 1880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 1890e2c34f92f00628d48968dfea096d36381f494cbStephen Hines /// Warn that L1 cannot be acquired before L2. 1900e2c34f92f00628d48968dfea096d36381f494cbStephen Hines virtual void handleLockAcquiredBefore(StringRef Kind, Name L1Name, 1910e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Name L2Name, SourceLocation Loc) {} 1920e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 1930e2c34f92f00628d48968dfea096d36381f494cbStephen Hines /// Warn that there is a cycle in acquired_before/after dependencies. 1940e2c34f92f00628d48968dfea096d36381f494cbStephen Hines virtual void handleBeforeAfterCycle(Name L1Name, SourceLocation Loc) {} 1950e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 196176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// Called by the analysis when starting analysis of a function. 197176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// Used to issue suggestions for changes to annotations. 198176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual void enterFunction(const FunctionDecl *FD) {} 199176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 200176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines /// Called by the analysis when finishing analysis of a function. 201176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual void leaveFunction(const FunctionDecl *FD) {} 202176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 203fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins bool issueBetaWarnings() { return IssueBetaWarnings; } 204fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins void setIssueBetaWarnings(bool b) { IssueBetaWarnings = b; } 205fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins 206fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchinsprivate: 207fb4afc2fc659faff43a6df4c1d0e07df9c90479dDeLesley Hutchins bool IssueBetaWarnings; 208402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 209402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 21019903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// \brief Check a function's CFG for thread-safety violations. 21119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// 21219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// We traverse the blocks in the CFG, compute the set of mutexes that are held 21319903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// at the end of each block, and issue warnings for thread safety violations. 21419903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// Each block in the CFG is traversed exactly once. 215ba243b59a1074e0962f6abfa3bb9aa984eac1245David Blaikievoid runThreadSafetyAnalysis(AnalysisDeclContext &AC, 2160e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyHandler &Handler, 2170e2c34f92f00628d48968dfea096d36381f494cbStephen Hines BeforeSet **Bset); 21819903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 2193ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarvoid threadSafetyCleanup(BeforeSet *Cache); 2203ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar 22119903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// \brief Helper function that returns a LockKind required for the given level 22219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski/// of access. 223402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin SadowskiLockKind getLockKindFromAccessKind(AccessKind AK); 224402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 225176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines}} // end namespace clang::threadSafety 226402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#endif 227