1402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski//===- ThreadSafety.cpp ----------------------------------------*- 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// A intra-procedural analysis for thread safety (e.g. deadlocks and race 11402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// conditions), based off of an annotation system. 12402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 136bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines// See http://clang.llvm.org/docs/ThreadSafetyAnalysis.html 14b96e74f79cc9f64a8d0080d4eff5d0431d2a48cfAaron Ballman// for more information. 15402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski// 16402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski//===----------------------------------------------------------------------===// 17402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 182fa67efeaf66a9332c30a026dc1c21bef6c33a6cBenjamin Kramer#include "clang/AST/Attr.h" 19402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "clang/AST/DeclCXX.h" 20402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "clang/AST/ExprCXX.h" 21402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "clang/AST/StmtCXX.h" 22402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "clang/AST/StmtVisitor.h" 2355fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Analysis/Analyses/PostOrderCFGView.h" 246bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines#include "clang/Analysis/Analyses/ThreadSafety.h" 250e2c34f92f00628d48968dfea096d36381f494cbStephen Hines#include "clang/Analysis/Analyses/ThreadSafetyCommon.h" 266bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines#include "clang/Analysis/Analyses/ThreadSafetyLogical.h" 276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines#include "clang/Analysis/Analyses/ThreadSafetyTIL.h" 286bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines#include "clang/Analysis/Analyses/ThreadSafetyTraverse.h" 2955fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Analysis/AnalysisContext.h" 3055fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Analysis/CFG.h" 3155fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Analysis/CFGStmtMap.h" 3296fac6a7fe89deff7860e536febbd4ae17bb57f3DeLesley Hutchins#include "clang/Basic/OperatorKinds.h" 332fa67efeaf66a9332c30a026dc1c21bef6c33a6cBenjamin Kramer#include "clang/Basic/SourceLocation.h" 342fa67efeaf66a9332c30a026dc1c21bef6c33a6cBenjamin Kramer#include "clang/Basic/SourceManager.h" 35402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/BitVector.h" 36402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/FoldingSet.h" 37402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/ImmutableMap.h" 38402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/PostOrderIterator.h" 39402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/SmallVector.h" 40402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include "llvm/ADT/StringRef.h" 41b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins#include "llvm/Support/raw_ostream.h" 42402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include <algorithm> 43176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include <ostream> 44176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include <sstream> 45b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins#include <utility> 46402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski#include <vector> 473ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarusing namespace clang; 483ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarusing namespace threadSafety; 49402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 5019903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski// Key method definition 5119903465e960329c0d5d93327f4046d036b0bc75Caitlin SadowskiThreadSafetyHandler::~ThreadSafetyHandler() {} 5219903465e960329c0d5d93327f4046d036b0bc75Caitlin Sadowski 533ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace { 54176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass TILPrinter : 55176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines public til::PrettyPrinter<TILPrinter, llvm::raw_ostream> {}; 56402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 57a74b715cdc37c4523818a4018faae99d977aa537DeLesley Hutchins 58176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// Issue a warning about an invalid lock expression 59176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesstatic void warnInvalidLock(ThreadSafetyHandler &Handler, 60176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const Expr *MutexExp, const NamedDecl *D, 61176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const Expr *DeclExp, StringRef Kind) { 62176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation Loc; 63176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (DeclExp) 64176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Loc = DeclExp->getExprLoc(); 65a74b715cdc37c4523818a4018faae99d977aa537DeLesley Hutchins 66176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // FIXME: add a note about the attribute location in MutexExp or D 67176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Loc.isValid()) 68176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleInvalidLockExp(Kind, Loc); 69176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines} 70ee2f032fe0fc86762608458c2a167ae504579a64DeLesley Hutchins 71176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// \brief A set of CapabilityInfo objects, which are compiled from the 72176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// requires attributes on a function. 73176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass CapExprSet : public SmallVector<CapabilityExpr, 4> { 745381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchinspublic: 75651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines /// \brief Push M onto list, but discard duplicates. 76176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void push_back_nodup(const CapabilityExpr &CapE) { 77176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines iterator It = std::find_if(begin(), end(), 78176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines [=](const CapabilityExpr &CapE2) { 79176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return CapE.equals(CapE2); 80176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines }); 81176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (It == end()) 82176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines push_back(CapE); 835381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins } 845381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins}; 855381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 86176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass FactManager; 87176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass FactSet; 88402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 89176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// \brief This is a helper class that stores a fact that is known at a 90176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// particular point in program execution. Currently, a fact is a capability, 91176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// along with additional information, such as where it was acquired, whether 92176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// it is exclusive or shared, etc. 93176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// 94176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// FIXME: this analysis does not currently support either re-entrant 95176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// locking or lock "upgrading" and "downgrading" between exclusive and 96176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// shared. 97176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass FactEntry : public CapabilityExpr { 98176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesprivate: 99176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LockKind LKind; ///< exclusive or shared 100176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation AcquireLoc; ///< where it was acquired. 101176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool Asserted; ///< true if the lock was asserted 1020e2c34f92f00628d48968dfea096d36381f494cbStephen Hines bool Declared; ///< true if the lock was declared 1030b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins 104176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinespublic: 105176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry(const CapabilityExpr &CE, LockKind LK, SourceLocation Loc, 1060e2c34f92f00628d48968dfea096d36381f494cbStephen Hines bool Asrt, bool Declrd = false) 1070e2c34f92f00628d48968dfea096d36381f494cbStephen Hines : CapabilityExpr(CE), LKind(LK), AcquireLoc(Loc), Asserted(Asrt), 1080e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Declared(Declrd) {} 109176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 110176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual ~FactEntry() {} 111176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1120e2c34f92f00628d48968dfea096d36381f494cbStephen Hines LockKind kind() const { return LKind; } 113176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation loc() const { return AcquireLoc; } 114176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool asserted() const { return Asserted; } 1150e2c34f92f00628d48968dfea096d36381f494cbStephen Hines bool declared() const { return Declared; } 1160e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 1170e2c34f92f00628d48968dfea096d36381f494cbStephen Hines void setDeclared(bool D) { Declared = D; } 118176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 119176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual void 120176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines handleRemovalFromIntersection(const FactSet &FSet, FactManager &FactMan, 121176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation JoinLoc, LockErrorKind LEK, 122176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ThreadSafetyHandler &Handler) const = 0; 123176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines virtual void handleUnlock(FactSet &FSet, FactManager &FactMan, 124176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CapabilityExpr &Cp, SourceLocation UnlockLoc, 125176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool FullyRemove, ThreadSafetyHandler &Handler, 126176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind) const = 0; 127176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 128176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Return true if LKind >= LK, where exclusive > shared 1290b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins bool isAtLeast(LockKind LK) { 130176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return (LKind == LK_Exclusive) || (LK == LK_Shared); 1310b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins } 132402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 133402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 134a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 135a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinstypedef unsigned short FactID; 136a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 137dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins/// \brief FactManager manages the memory for all facts that are created during 138a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// the analysis of a single routine. 139a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsclass FactManager { 140a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsprivate: 141176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines std::vector<std::unique_ptr<FactEntry>> Facts; 142a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 143a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinspublic: 144176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactID newFact(std::unique_ptr<FactEntry> Entry) { 145176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Facts.push_back(std::move(Entry)); 146a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return static_cast<unsigned short>(Facts.size() - 1); 147a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 148a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 149176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry &operator[](FactID F) const { return *Facts[F]; } 150176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry &operator[](FactID F) { return *Facts[F]; } 151a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins}; 152a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 153a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 154a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// \brief A FactSet is the set of facts that are known to be true at a 155dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins/// particular program point. FactSets must be small, because they are 156a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// frequently copied, and are thus implemented as a set of indices into a 157dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins/// table maintained by a FactManager. A typical FactSet only holds 1 or 2 158a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// locks, so we can get away with doing a linear search for lookup. Note 159a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// that a hashtable or map is inappropriate in this case, because lookups 160a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins/// may involve partial pattern matches, rather than exact matches. 161a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsclass FactSet { 162a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsprivate: 163a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins typedef SmallVector<FactID, 4> FactVec; 164a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 165a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactVec FactIDs; 166a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 167a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinspublic: 168a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins typedef FactVec::iterator iterator; 169a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins typedef FactVec::const_iterator const_iterator; 170a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 171a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins iterator begin() { return FactIDs.begin(); } 172a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const_iterator begin() const { return FactIDs.begin(); } 173a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 174a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins iterator end() { return FactIDs.end(); } 175a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const_iterator end() const { return FactIDs.end(); } 176a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 177a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins bool isEmpty() const { return FactIDs.size() == 0; } 178a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 179176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Return true if the set contains only negative facts 180176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool isEmpty(FactManager &FactMan) const { 181176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines for (FactID FID : *this) { 182176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!FactMan[FID].negative()) 183176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return false; 184176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 185176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return true; 186176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 187176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 188176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void addLockByID(FactID ID) { FactIDs.push_back(ID); } 189176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 190176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactID addLock(FactManager &FM, std::unique_ptr<FactEntry> Entry) { 191176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactID F = FM.newFact(std::move(Entry)); 192a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactIDs.push_back(F); 193a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return F; 194a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 195a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 196176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool removeLock(FactManager& FM, const CapabilityExpr &CapE) { 197a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins unsigned n = FactIDs.size(); 198a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins if (n == 0) 199a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return false; 200a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 201a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins for (unsigned i = 0; i < n-1; ++i) { 202176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FM[FactIDs[i]].matches(CapE)) { 203a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactIDs[i] = FactIDs[n-1]; 204a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactIDs.pop_back(); 205a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return true; 206a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 207a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 208176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FM[FactIDs[n-1]].matches(CapE)) { 209a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactIDs.pop_back(); 210a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return true; 211a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 212a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return false; 213a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 214a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 215176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines iterator findLockIter(FactManager &FM, const CapabilityExpr &CapE) { 2166bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return std::find_if(begin(), end(), [&](FactID ID) { 217176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return FM[ID].matches(CapE); 2186bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines }); 219451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins } 220451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins 221176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry *findLock(FactManager &FM, const CapabilityExpr &CapE) const { 2226bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto I = std::find_if(begin(), end(), [&](FactID ID) { 223176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return FM[ID].matches(CapE); 2246bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines }); 225176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return I != end() ? &FM[*I] : nullptr; 226a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 2273f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins 228176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry *findLockUniv(FactManager &FM, const CapabilityExpr &CapE) const { 2296bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines auto I = std::find_if(begin(), end(), [&](FactID ID) -> bool { 230176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return FM[ID].matchesUniv(CapE); 2316bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines }); 232176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return I != end() ? &FM[*I] : nullptr; 2333f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins } 234a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 235176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry *findPartialMatch(FactManager &FM, 236176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CapabilityExpr &CapE) const { 2370e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto I = std::find_if(begin(), end(), [&](FactID ID) -> bool { 238176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return FM[ID].partiallyMatches(CapE); 2396bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines }); 2406bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return I != end() ? &FM[*I] : nullptr; 2416bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } 2420e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2430e2c34f92f00628d48968dfea096d36381f494cbStephen Hines bool containsMutexDecl(FactManager &FM, const ValueDecl* Vd) const { 2440e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto I = std::find_if(begin(), end(), [&](FactID ID) -> bool { 2450e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return FM[ID].valueDecl() == Vd; 2460e2c34f92f00628d48968dfea096d36381f494cbStephen Hines }); 2470e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return I != end(); 2480e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 2490e2c34f92f00628d48968dfea096d36381f494cbStephen Hines}; 2500e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2510e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesclass ThreadSafetyAnalyzer; 2523ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // namespace 2530e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2543ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace clang { 2553ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace threadSafety { 2560e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesclass BeforeSet { 2570e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesprivate: 2580e2c34f92f00628d48968dfea096d36381f494cbStephen Hines typedef SmallVector<const ValueDecl*, 4> BeforeVect; 2590e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2600e2c34f92f00628d48968dfea096d36381f494cbStephen Hines struct BeforeInfo { 26187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo() : Visited(0) {} 26287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo(BeforeInfo &&O) : Vect(std::move(O.Vect)), Visited(O.Visited) {} 2630e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 26487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeVect Vect; 26587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar int Visited; 2660e2c34f92f00628d48968dfea096d36381f494cbStephen Hines }; 2670e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 26887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar typedef llvm::DenseMap<const ValueDecl *, std::unique_ptr<BeforeInfo>> 26987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeMap; 2700e2c34f92f00628d48968dfea096d36381f494cbStephen Hines typedef llvm::DenseMap<const ValueDecl*, bool> CycleMap; 2710e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2720e2c34f92f00628d48968dfea096d36381f494cbStephen Hinespublic: 2730e2c34f92f00628d48968dfea096d36381f494cbStephen Hines BeforeSet() { } 2740e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2750e2c34f92f00628d48968dfea096d36381f494cbStephen Hines BeforeInfo* insertAttrExprs(const ValueDecl* Vd, 2760e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer& Analyzer); 2770e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 27887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo *getBeforeInfoForDecl(const ValueDecl *Vd, 27987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ThreadSafetyAnalyzer &Analyzer); 28087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 2810e2c34f92f00628d48968dfea096d36381f494cbStephen Hines void checkBeforeAfter(const ValueDecl* Vd, 2820e2c34f92f00628d48968dfea096d36381f494cbStephen Hines const FactSet& FSet, 2830e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer& Analyzer, 2840e2c34f92f00628d48968dfea096d36381f494cbStephen Hines SourceLocation Loc, StringRef CapKind); 2850e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2860e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesprivate: 2870e2c34f92f00628d48968dfea096d36381f494cbStephen Hines BeforeMap BMap; 2880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines CycleMap CycMap; 2896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines}; 2903ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // end namespace threadSafety 2913ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // end namespace clang 292a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 2933ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace { 294176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinestypedef llvm::ImmutableMap<const NamedDecl*, unsigned> LocalVarContext; 295b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsclass LocalVariableMap; 296b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 2972e5156274b8051217565b557bfa14c80f7990e9cRichard Smith/// A side (entry or exit) of a CFG node. 2982e5156274b8051217565b557bfa14c80f7990e9cRichard Smithenum CFGBlockSide { CBS_Entry, CBS_Exit }; 299b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 300b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins/// CFGBlockInfo is a struct which contains all the information that is 301b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins/// maintained for each block in the CFG. See LocalVariableMap for more 302b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins/// information about the contexts. 303b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsstruct CFGBlockInfo { 304a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet EntrySet; // Lockset held at entry to block 305a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet ExitSet; // Lockset held at exit from block 306b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVarContext EntryContext; // Context held at entry to block 307b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVarContext ExitContext; // Context held at exit from block 3082e5156274b8051217565b557bfa14c80f7990e9cRichard Smith SourceLocation EntryLoc; // Location of first statement in block 3092e5156274b8051217565b557bfa14c80f7990e9cRichard Smith SourceLocation ExitLoc; // Location of last statement in block. 310b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned EntryIndex; // Used to replay contexts later 311d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins bool Reachable; // Is this block reachable? 312b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 313a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const FactSet &getSet(CFGBlockSide Side) const { 3142e5156274b8051217565b557bfa14c80f7990e9cRichard Smith return Side == CBS_Entry ? EntrySet : ExitSet; 3152e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 3162e5156274b8051217565b557bfa14c80f7990e9cRichard Smith SourceLocation getLocation(CFGBlockSide Side) const { 3172e5156274b8051217565b557bfa14c80f7990e9cRichard Smith return Side == CBS_Entry ? EntryLoc : ExitLoc; 3182e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 3192e5156274b8051217565b557bfa14c80f7990e9cRichard Smith 320b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsprivate: 321a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins CFGBlockInfo(LocalVarContext EmptyCtx) 322d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins : EntryContext(EmptyCtx), ExitContext(EmptyCtx), Reachable(false) 323b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins { } 324b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 325b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinspublic: 326a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins static CFGBlockInfo getEmptyBlockInfo(LocalVariableMap &M); 327b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins}; 328b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 329b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 330b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 331b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// A LocalVariableMap maintains a map from local variables to their currently 332b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// valid definitions. It provides SSA-like functionality when traversing the 333b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// CFG. Like SSA, each definition or assignment to a variable is assigned a 334b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// unique name (an integer), which acts as the SSA name for that definition. 335b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// The total set of names is shared among all CFG basic blocks. 336b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Unlike SSA, we do not rewrite expressions to replace local variables declrefs 337b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// with their SSA-names. Instead, we compute a Context for each point in the 338b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// code, which maps local variables to the appropriate SSA-name. This map 339b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// changes with each assignment. 340b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 341b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// The map is computed in a single pass over the CFG. Subsequent analyses can 342b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// then query the map to find the appropriate Context for a statement, and use 343b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// that Context to look up the definitions of variables. 344b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsclass LocalVariableMap { 345b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinspublic: 346b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins typedef LocalVarContext Context; 347b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 348b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// A VarDefinition consists of an expression, representing the value of the 349b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// variable, along with the context in which that expression should be 350b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// interpreted. A reference VarDefinition does not itself contain this 351b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// information, but instead contains a pointer to a previous VarDefinition. 352b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins struct VarDefinition { 353b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins public: 354b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins friend class LocalVariableMap; 355b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 35654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const NamedDecl *Dec; // The original declaration for this variable. 35754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const Expr *Exp; // The expression for this variable, OR 35854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins unsigned Ref; // Reference to another VarDefinition 35954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Context Ctx; // The map with which Exp should be interpreted. 360b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 361b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins bool isReference() { return !Exp; } 362b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 363b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins private: 364b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Create ordinary variable definition 36554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins VarDefinition(const NamedDecl *D, const Expr *E, Context C) 366b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins : Dec(D), Exp(E), Ref(0), Ctx(C) 367b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins { } 368b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 369b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Create reference to previous definition 37054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins VarDefinition(const NamedDecl *D, unsigned R, Context C) 3716bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines : Dec(D), Exp(nullptr), Ref(R), Ctx(C) 372b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins { } 373b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins }; 374b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 375b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsprivate: 376b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context::Factory ContextFactory; 377b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins std::vector<VarDefinition> VarDefinitions; 378b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins std::vector<unsigned> CtxIndices; 379b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins std::vector<std::pair<Stmt*, Context> > SavedContexts; 380b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 381b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinspublic: 382b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVariableMap() { 383b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // index 0 is a placeholder for undefined variables (aka phi-nodes). 3846bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines VarDefinitions.push_back(VarDefinition(nullptr, 0u, getEmptyContext())); 385b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 386b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 387b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Look up a definition, within the given context. 38854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const VarDefinition* lookup(const NamedDecl *D, Context Ctx) { 389b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins const unsigned *i = Ctx.lookup(D); 390b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!i) 3916bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 392b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins assert(*i < VarDefinitions.size()); 393b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return &VarDefinitions[*i]; 394b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 395b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 396b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Look up the definition for D within the given context. Returns 397b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins /// NULL if the expression is not statically known. If successful, also 398b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins /// modifies Ctx to hold the context of the return Expr. 39954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const Expr* lookupExpr(const NamedDecl *D, Context &Ctx) { 400b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins const unsigned *P = Ctx.lookup(D); 401b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!P) 4026bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 403b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 404b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned i = *P; 405b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins while (i > 0) { 406b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins if (VarDefinitions[i].Exp) { 407b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins Ctx = VarDefinitions[i].Ctx; 408b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return VarDefinitions[i].Exp; 409b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins } 410b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins i = VarDefinitions[i].Ref; 411b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 4126bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 413b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 414b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 415b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context getEmptyContext() { return ContextFactory.getEmptyMap(); } 416b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 417b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Return the next context after processing S. This function is used by 418b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// clients of the class to get the appropriate context when traversing the 419b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// CFG. It must be called for every assignment or DeclStmt. 420b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context getNextContext(unsigned &CtxIndex, Stmt *S, Context C) { 421b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (SavedContexts[CtxIndex+1].first == S) { 422b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CtxIndex++; 423b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context Result = SavedContexts[CtxIndex].second; 424b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return Result; 425b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 426b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return C; 427b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 428b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 429b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void dumpVarDefinitionName(unsigned i) { 430b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (i == 0) { 431b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << "Undefined"; 432b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return; 433b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 43454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const NamedDecl *Dec = VarDefinitions[i].Dec; 435b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!Dec) { 436b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << "<<NULL>>"; 437b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return; 438b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 439b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Dec->printName(llvm::errs()); 44031ba6135375433b617a8587ea6cc836a014ebd86Roman Divacky llvm::errs() << "." << i << " " << ((const void*) Dec); 441b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 442b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 443b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Dumps an ASCII representation of the variable map to llvm::errs() 444b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void dump() { 445b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins for (unsigned i = 1, e = VarDefinitions.size(); i < e; ++i) { 44654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const Expr *Exp = VarDefinitions[i].Exp; 447b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned Ref = VarDefinitions[i].Ref; 448b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 449b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins dumpVarDefinitionName(i); 450b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << " = "; 451b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (Exp) Exp->dump(); 452b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins else { 453b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins dumpVarDefinitionName(Ref); 454b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << "\n"; 455b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 456b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 457b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 458b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 459b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Dumps an ASCII representation of a Context to llvm::errs() 460b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void dumpContext(Context C) { 461b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins for (Context::iterator I = C.begin(), E = C.end(); I != E; ++I) { 46254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const NamedDecl *D = I.getKey(); 463b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins D->printName(llvm::errs()); 464b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins const unsigned *i = C.lookup(D); 465b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << " -> "; 466b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins dumpVarDefinitionName(*i); 467b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins llvm::errs() << "\n"; 468b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 469b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 470b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 471b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins /// Builds the variable map. 4726bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines void traverseCFG(CFG *CFGraph, const PostOrderCFGView *SortedGraph, 4736bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines std::vector<CFGBlockInfo> &BlockInfo); 474b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 475b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsprotected: 476b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Get the current context index 477b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned getContextIndex() { return SavedContexts.size()-1; } 478b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 479b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Save the current context for later replay 480b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void saveContext(Stmt *S, Context C) { 481b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins SavedContexts.push_back(std::make_pair(S,C)); 482b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 483b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 484b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Adds a new definition to the given context, and returns a new context. 485b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // This method should be called when declaring a new variable. 4866bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Context addDefinition(const NamedDecl *D, const Expr *Exp, Context Ctx) { 487b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins assert(!Ctx.contains(D)); 488b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned newID = VarDefinitions.size(); 489b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context NewCtx = ContextFactory.add(Ctx, D, newID); 490b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarDefinitions.push_back(VarDefinition(D, Exp, Ctx)); 491b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return NewCtx; 492b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 493b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 494b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Add a new reference to an existing definition. 49554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Context addReference(const NamedDecl *D, unsigned i, Context Ctx) { 496b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned newID = VarDefinitions.size(); 497b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context NewCtx = ContextFactory.add(Ctx, D, newID); 498b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarDefinitions.push_back(VarDefinition(D, i, Ctx)); 499b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return NewCtx; 500b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 501b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 502b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Updates a definition only if that definition is already in the map. 503b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // This method should be called when assigning to an existing variable. 50454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Context updateDefinition(const NamedDecl *D, Expr *Exp, Context Ctx) { 505b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (Ctx.contains(D)) { 506b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned newID = VarDefinitions.size(); 507b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context NewCtx = ContextFactory.remove(Ctx, D); 508b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins NewCtx = ContextFactory.add(NewCtx, D, newID); 509b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarDefinitions.push_back(VarDefinition(D, Exp, Ctx)); 510b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return NewCtx; 511b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 512b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return Ctx; 513b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 514b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 515b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Removes a definition from the context, but keeps the variable name 516b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // as a valid variable. The index 0 is a placeholder for cleared definitions. 51754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Context clearDefinition(const NamedDecl *D, Context Ctx) { 518b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context NewCtx = Ctx; 519b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (NewCtx.contains(D)) { 520b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins NewCtx = ContextFactory.remove(NewCtx, D); 521b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins NewCtx = ContextFactory.add(NewCtx, D, 0); 522b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 523b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return NewCtx; 524b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 525b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 526b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Remove a definition entirely frmo the context. 52754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Context removeDefinition(const NamedDecl *D, Context Ctx) { 528b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context NewCtx = Ctx; 529b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (NewCtx.contains(D)) { 530b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins NewCtx = ContextFactory.remove(NewCtx, D); 531b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 532b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return NewCtx; 533b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 534b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 535b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context intersectContexts(Context C1, Context C2); 536b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context createReferenceContext(Context C); 537b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void intersectBackEdge(Context C1, Context C2); 538b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 539b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins friend class VarMapBuilder; 540b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins}; 541b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 542b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 543b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// This has to be defined after LocalVariableMap. 544a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley HutchinsCFGBlockInfo CFGBlockInfo::getEmptyBlockInfo(LocalVariableMap &M) { 545a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return CFGBlockInfo(M.getEmptyContext()); 546b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 547b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 548b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 549b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins/// Visitor which builds a LocalVariableMap 550b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsclass VarMapBuilder : public StmtVisitor<VarMapBuilder> { 551b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinspublic: 552b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVariableMap* VMap; 553b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVariableMap::Context Ctx; 554b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 555b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarMapBuilder(LocalVariableMap *VM, LocalVariableMap::Context C) 556b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins : VMap(VM), Ctx(C) {} 557b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 558b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void VisitDeclStmt(DeclStmt *S); 559b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins void VisitBinaryOperator(BinaryOperator *BO); 560b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins}; 561b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 562b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 563b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Add new local variables to the variable map 564b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsvoid VarMapBuilder::VisitDeclStmt(DeclStmt *S) { 565b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins bool modifiedCtx = false; 566b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins DeclGroupRef DGrp = S->getDeclGroup(); 5676bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *D : DGrp) { 5686bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *VD = dyn_cast_or_null<VarDecl>(D)) { 5696bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const Expr *E = VD->getInit(); 570b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 571b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Add local variables with trivial type to the variable map 572b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins QualType T = VD->getType(); 573b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (T.isTrivialType(VD->getASTContext())) { 574b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Ctx = VMap->addDefinition(VD, E, Ctx); 575b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins modifiedCtx = true; 576b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 577b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 578b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 579b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (modifiedCtx) 580b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VMap->saveContext(S, Ctx); 581b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 582b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 583b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Update local variable definitions in variable map 584b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsvoid VarMapBuilder::VisitBinaryOperator(BinaryOperator *BO) { 585b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!BO->isAssignmentOp()) 586b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return; 587b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 588b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Expr *LHSExp = BO->getLHS()->IgnoreParenCasts(); 589b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 590b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Update the variable map and current context. 591b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(LHSExp)) { 592b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins ValueDecl *VDec = DRE->getDecl(); 593b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (Ctx.lookup(VDec)) { 594b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (BO->getOpcode() == BO_Assign) 595b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Ctx = VMap->updateDefinition(VDec, BO->getRHS(), Ctx); 596b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins else 597b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // FIXME -- handle compound assignment operators 598b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Ctx = VMap->clearDefinition(VDec, Ctx); 599b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VMap->saveContext(BO, Ctx); 600b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 601b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 602b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 603b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 604b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 605b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Computes the intersection of two contexts. The intersection is the 606b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// set of variables which have the same definition in both contexts; 607b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// variables with different definitions are discarded. 608b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley HutchinsLocalVariableMap::Context 609b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley HutchinsLocalVariableMap::intersectContexts(Context C1, Context C2) { 610b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context Result = C1; 6116bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &P : C1) { 6126bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const NamedDecl *Dec = P.first; 613b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins const unsigned *i2 = C2.lookup(Dec); 614b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!i2) // variable doesn't exist on second path 615b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Result = removeDefinition(Dec, Result); 6166bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines else if (*i2 != P.second) // variable exists, but has different definition 617b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Result = clearDefinition(Dec, Result); 618b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 619b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return Result; 620b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 621b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 622b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// For every variable in C, create a new variable that refers to the 623b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// definition in C. Return a new context that contains these new variables. 624b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// (We use this for a naive implementation of SSA on loop back-edges.) 625b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley HutchinsLocalVariableMap::Context LocalVariableMap::createReferenceContext(Context C) { 626b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context Result = getEmptyContext(); 6276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &P : C) 6286bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines Result = addReference(P.first, P.second, Result); 629b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins return Result; 630b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 631b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 632b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// This routine also takes the intersection of C1 and C2, but it does so by 633b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// altering the VarDefinitions. C1 must be the result of an earlier call to 634b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// createReferenceContext. 635b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsvoid LocalVariableMap::intersectBackEdge(Context C1, Context C2) { 6366bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &P : C1) { 6376bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines unsigned i1 = P.second; 638b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarDefinition *VDef = &VarDefinitions[i1]; 639b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins assert(VDef->isReference()); 640b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 6416bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const unsigned *i2 = C2.lookup(P.first); 642b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (!i2 || (*i2 != i1)) 643b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VDef->Ref = 0; // Mark this variable as undefined 644b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 645b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 646b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 647b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 648b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Traverse the CFG in topological order, so all predecessors of a block 649b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// (excluding back-edges) are visited before the block itself. At 650b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// each point in the code, we calculate a Context, which holds the set of 651b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// variable definitions which are visible at that point in execution. 652b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// Visible variables are mapped to their definitions using an array that 653b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// contains all definitions. 654b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 655b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// At join points in the CFG, the set is computed as the intersection of 656b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// the incoming sets along each edge, E.g. 657b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 658b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// { Context | VarDefinitions } 659b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// int x = 0; { x -> x1 | x1 = 0 } 660b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// int y = 0; { x -> x1, y -> y1 | y1 = 0, x1 = 0 } 661b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// if (b) x = 1; { x -> x2, y -> y1 | x2 = 1, y1 = 0, ... } 662b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// else x = 2; { x -> x3, y -> y1 | x3 = 2, x2 = 1, ... } 663b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// ... { y -> y1 (x is unknown) | x3 = 2, x2 = 1, ... } 664b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 665b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// This is essentially a simpler and more naive version of the standard SSA 666b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// algorithm. Those definitions that remain in the intersection are from blocks 667b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// that strictly dominate the current block. We do not bother to insert proper 668b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// phi nodes, because they are not used in our analysis; instead, wherever 669b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// a phi node would be required, we simply remove that definition from the 670b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// context (E.g. x above). 671b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 672b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// The initial traversal does not capture back-edges, so those need to be 673b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// handled on a separate pass. Whenever the first pass encounters an 674b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// incoming back edge, it duplicates the context, creating new definitions 675b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// that refer back to the originals. (These correspond to places where SSA 676b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// might have to insert a phi node.) On the second pass, these definitions are 677bed28ac1d1463adca3ecf24fca5c30646fa9dbb2Sylvestre Ledru// set to NULL if the variable has changed on the back-edge (i.e. a phi 678b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// node was actually required.) E.g. 679b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 680b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// { Context | VarDefinitions } 681b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// int x = 0, y = 0; { x -> x1, y -> y1 | y1 = 0, x1 = 0 } 682b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// while (b) { x -> x2, y -> y1 | [1st:] x2=x1; [2nd:] x2=NULL; } 683b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// x = x+1; { x -> x3, y -> y1 | x3 = x2 + 1, ... } 684b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// ... { y -> y1 | x3 = 2, x2 = 1, ... } 685b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins// 686b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsvoid LocalVariableMap::traverseCFG(CFG *CFGraph, 6876bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const PostOrderCFGView *SortedGraph, 688b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins std::vector<CFGBlockInfo> &BlockInfo) { 689b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins PostOrderCFGView::CFGBlockSet VisitedBlocks(CFGraph); 690b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 691b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CtxIndices.resize(CFGraph->getNumBlockIDs()); 692b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 6936bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *CurrBlock : *SortedGraph) { 694b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins int CurrBlockID = CurrBlock->getBlockID(); 695b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlockID]; 696b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 697b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VisitedBlocks.insert(CurrBlock); 698b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 699b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Calculate the entry context for the current block 700b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins bool HasBackEdges = false; 701b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins bool CtxInit = true; 702b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(), 703b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins PE = CurrBlock->pred_end(); PI != PE; ++PI) { 704b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // if *PI -> CurrBlock is a back edge, so skip it 7056bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (*PI == nullptr || !VisitedBlocks.alreadySet(*PI)) { 706b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins HasBackEdges = true; 707b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins continue; 708b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 709b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 710b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins int PrevBlockID = (*PI)->getBlockID(); 711b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CFGBlockInfo *PrevBlockInfo = &BlockInfo[PrevBlockID]; 712b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 713b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (CtxInit) { 714b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CurrBlockInfo->EntryContext = PrevBlockInfo->ExitContext; 715b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CtxInit = false; 716b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 717b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins else { 718b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CurrBlockInfo->EntryContext = 719b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins intersectContexts(CurrBlockInfo->EntryContext, 720b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins PrevBlockInfo->ExitContext); 721b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 722b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 723b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 724b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Duplicate the context if we have back-edges, so we can call 725b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // intersectBackEdges later. 726b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins if (HasBackEdges) 727b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CurrBlockInfo->EntryContext = 728b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins createReferenceContext(CurrBlockInfo->EntryContext); 729b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 730b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Create a starting context index for the current block 7316bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines saveContext(nullptr, CurrBlockInfo->EntryContext); 732b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CurrBlockInfo->EntryIndex = getContextIndex(); 733b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 734b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Visit all the statements in the basic block. 735b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VarMapBuilder VMapBuilder(this, CurrBlockInfo->EntryContext); 736b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins for (CFGBlock::const_iterator BI = CurrBlock->begin(), 737b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins BE = CurrBlock->end(); BI != BE; ++BI) { 738b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins switch (BI->getKind()) { 739b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins case CFGElement::Statement: { 740fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie CFGStmt CS = BI->castAs<CFGStmt>(); 741fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie VMapBuilder.Visit(const_cast<Stmt*>(CS.getStmt())); 742b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins break; 743b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 744b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins default: 745b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins break; 746b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 747b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 748b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CurrBlockInfo->ExitContext = VMapBuilder.Ctx; 749b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 750b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Mark variables on back edges as "unknown" if they've been changed. 751b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(), 752b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins SE = CurrBlock->succ_end(); SI != SE; ++SI) { 753b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // if CurrBlock -> *SI is *not* a back edge 7546bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (*SI == nullptr || !VisitedBlocks.alreadySet(*SI)) 755b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins continue; 756b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 757b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CFGBlock *FirstLoopBlock = *SI; 758b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context LoopBegin = BlockInfo[FirstLoopBlock->getBlockID()].EntryContext; 759b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins Context LoopEnd = CurrBlockInfo->ExitContext; 760b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins intersectBackEdge(LoopBegin, LoopEnd); 761b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 762b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins } 763b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 764b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Put an extra entry at the end of the indexed context array 765b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins unsigned exitID = CFGraph->getExit().getBlockID(); 7666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines saveContext(nullptr, BlockInfo[exitID].ExitContext); 767b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins} 768b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 7692e5156274b8051217565b557bfa14c80f7990e9cRichard Smith/// Find the appropriate source locations to use when producing diagnostics for 7702e5156274b8051217565b557bfa14c80f7990e9cRichard Smith/// each block in the CFG. 7712e5156274b8051217565b557bfa14c80f7990e9cRichard Smithstatic void findBlockLocations(CFG *CFGraph, 7726bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const PostOrderCFGView *SortedGraph, 7732e5156274b8051217565b557bfa14c80f7990e9cRichard Smith std::vector<CFGBlockInfo> &BlockInfo) { 7746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *CurrBlock : *SortedGraph) { 7752e5156274b8051217565b557bfa14c80f7990e9cRichard Smith CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlock->getBlockID()]; 7762e5156274b8051217565b557bfa14c80f7990e9cRichard Smith 7772e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // Find the source location of the last statement in the block, if the 7782e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // block is not empty. 7792e5156274b8051217565b557bfa14c80f7990e9cRichard Smith if (const Stmt *S = CurrBlock->getTerminator()) { 7802e5156274b8051217565b557bfa14c80f7990e9cRichard Smith CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc = S->getLocStart(); 7812e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } else { 7822e5156274b8051217565b557bfa14c80f7990e9cRichard Smith for (CFGBlock::const_reverse_iterator BI = CurrBlock->rbegin(), 7832e5156274b8051217565b557bfa14c80f7990e9cRichard Smith BE = CurrBlock->rend(); BI != BE; ++BI) { 7842e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // FIXME: Handle other CFGElement kinds. 785b07805485c603be3d8011f72611465324c9e664bDavid Blaikie if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>()) { 786b07805485c603be3d8011f72611465324c9e664bDavid Blaikie CurrBlockInfo->ExitLoc = CS->getStmt()->getLocStart(); 7872e5156274b8051217565b557bfa14c80f7990e9cRichard Smith break; 7882e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 7892e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 7902e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 7912e5156274b8051217565b557bfa14c80f7990e9cRichard Smith 79287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (CurrBlockInfo->ExitLoc.isValid()) { 7932e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // This block contains at least one statement. Find the source location 7942e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // of the first statement in the block. 7952e5156274b8051217565b557bfa14c80f7990e9cRichard Smith for (CFGBlock::const_iterator BI = CurrBlock->begin(), 7962e5156274b8051217565b557bfa14c80f7990e9cRichard Smith BE = CurrBlock->end(); BI != BE; ++BI) { 7972e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // FIXME: Handle other CFGElement kinds. 798b07805485c603be3d8011f72611465324c9e664bDavid Blaikie if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>()) { 799b07805485c603be3d8011f72611465324c9e664bDavid Blaikie CurrBlockInfo->EntryLoc = CS->getStmt()->getLocStart(); 8002e5156274b8051217565b557bfa14c80f7990e9cRichard Smith break; 8012e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 8022e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 8032e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } else if (CurrBlock->pred_size() == 1 && *CurrBlock->pred_begin() && 8042e5156274b8051217565b557bfa14c80f7990e9cRichard Smith CurrBlock != &CFGraph->getExit()) { 8052e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // The block is empty, and has a single predecessor. Use its exit 8062e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // location. 8072e5156274b8051217565b557bfa14c80f7990e9cRichard Smith CurrBlockInfo->EntryLoc = CurrBlockInfo->ExitLoc = 8082e5156274b8051217565b557bfa14c80f7990e9cRichard Smith BlockInfo[(*CurrBlock->pred_begin())->getBlockID()].ExitLoc; 8092e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 8102e5156274b8051217565b557bfa14c80f7990e9cRichard Smith } 8112e5156274b8051217565b557bfa14c80f7990e9cRichard Smith} 812b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 813176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass LockableFactEntry : public FactEntry { 814176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesprivate: 815176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool Managed; ///< managed by ScopedLockable object 816176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 817176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinespublic: 818176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LockableFactEntry(const CapabilityExpr &CE, LockKind LK, SourceLocation Loc, 819176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool Mng = false, bool Asrt = false) 820176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines : FactEntry(CE, LK, Loc, Asrt), Managed(Mng) {} 821176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 822176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void 823176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines handleRemovalFromIntersection(const FactSet &FSet, FactManager &FactMan, 824176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation JoinLoc, LockErrorKind LEK, 825176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ThreadSafetyHandler &Handler) const override { 826176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Managed && !asserted() && !negative() && !isUniversal()) { 827176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleMutexHeldEndOfScope("mutex", toString(), loc(), JoinLoc, 828176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LEK); 829176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 830176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 831176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 832176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void handleUnlock(FactSet &FSet, FactManager &FactMan, 833176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CapabilityExpr &Cp, SourceLocation UnlockLoc, 834176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool FullyRemove, ThreadSafetyHandler &Handler, 835176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind) const override { 836176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.removeLock(FactMan, Cp); 837176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Cp.negative()) { 838176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.addLock(FactMan, llvm::make_unique<LockableFactEntry>( 839176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines !Cp, LK_Exclusive, UnlockLoc)); 840176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 841176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 842176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines}; 843176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 844176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesclass ScopedLockableFactEntry : public FactEntry { 845176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesprivate: 846176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SmallVector<const til::SExpr *, 4> UnderlyingMutexes; 847176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 848176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinespublic: 849176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ScopedLockableFactEntry(const CapabilityExpr &CE, SourceLocation Loc, 850176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CapExprSet &Excl, const CapExprSet &Shrd) 851176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines : FactEntry(CE, LK_Exclusive, Loc, false) { 852176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines for (const auto &M : Excl) 853176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines UnderlyingMutexes.push_back(M.sexpr()); 854176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines for (const auto &M : Shrd) 855176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines UnderlyingMutexes.push_back(M.sexpr()); 856176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 857176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 858176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void 859176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines handleRemovalFromIntersection(const FactSet &FSet, FactManager &FactMan, 860176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation JoinLoc, LockErrorKind LEK, 861176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ThreadSafetyHandler &Handler) const override { 862176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines for (const til::SExpr *UnderlyingMutex : UnderlyingMutexes) { 863176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FSet.findLock(FactMan, CapabilityExpr(UnderlyingMutex, false))) { 864176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If this scoped lock manages another mutex, and if the underlying 865176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // mutex is still held, then warn about the underlying mutex. 866176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleMutexHeldEndOfScope( 867176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "mutex", sx::toString(UnderlyingMutex), loc(), JoinLoc, LEK); 868176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 869176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 870176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 871176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 872176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void handleUnlock(FactSet &FSet, FactManager &FactMan, 873176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CapabilityExpr &Cp, SourceLocation UnlockLoc, 874176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool FullyRemove, ThreadSafetyHandler &Handler, 875176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind) const override { 876176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(!Cp.negative() && "Managing object cannot be negative."); 877176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines for (const til::SExpr *UnderlyingMutex : UnderlyingMutexes) { 878176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr UnderCp(UnderlyingMutex, false); 879176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines auto UnderEntry = llvm::make_unique<LockableFactEntry>( 880176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines !UnderCp, LK_Exclusive, UnlockLoc); 881176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 882176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FullyRemove) { 883176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // We're destroying the managing object. 884176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Remove the underlying mutex if it exists; but don't warn. 885176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FSet.findLock(FactMan, UnderCp)) { 886176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.removeLock(FactMan, UnderCp); 887176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.addLock(FactMan, std::move(UnderEntry)); 888176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 889176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } else { 890176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // We're releasing the underlying mutex, but not destroying the 891176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // managing object. Warn on dual release. 892176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!FSet.findLock(FactMan, UnderCp)) { 893176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleUnmatchedUnlock(DiagKind, UnderCp.toString(), 894176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines UnlockLoc); 895176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 896176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.removeLock(FactMan, UnderCp); 897176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.addLock(FactMan, std::move(UnderEntry)); 898176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 899176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 900176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FullyRemove) 901176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.removeLock(FactMan, Cp); 902176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 903176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines}; 904176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 905b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins/// \brief Class which implements the core thread safety analysis routines. 906b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinsclass ThreadSafetyAnalyzer { 907b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins friend class BuildLockset; 9083ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar friend class threadSafety::BeforeSet; 909b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 910176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::BumpPtrAllocator Bpa; 911176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines threadSafety::til::MemRegionRef Arena; 912176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines threadSafety::SExprBuilder SxBuilder; 913176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 91454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins ThreadSafetyHandler &Handler; 915176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const CXXMethodDecl *CurrentMethod; 91654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LocalVariableMap LocalVarMap; 917a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactManager FactMan; 91854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins std::vector<CFGBlockInfo> BlockInfo; 919b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 9200e2c34f92f00628d48968dfea096d36381f494cbStephen Hines BeforeSet* GlobalBeforeSet; 9210e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 922b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchinspublic: 9230e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer(ThreadSafetyHandler &H, BeforeSet* Bset) 9240e2c34f92f00628d48968dfea096d36381f494cbStephen Hines : Arena(&Bpa), SxBuilder(Arena), Handler(H), GlobalBeforeSet(Bset) {} 925b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 926176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool inCurrentScope(const CapabilityExpr &CapE); 927176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 928176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void addLock(FactSet &FSet, std::unique_ptr<FactEntry> Entry, 929176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind, bool ReqAttr = false); 930176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void removeLock(FactSet &FSet, const CapabilityExpr &CapE, 931176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation UnlockLoc, bool FullyRemove, LockKind Kind, 932176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind); 933a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 9345381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins template <typename AttrType> 935176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, Expr *Exp, 9366bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const NamedDecl *D, VarDecl *SelfDecl = nullptr); 937402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 938b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins template <class AttrType> 939176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, Expr *Exp, 9405381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins const NamedDecl *D, 9415381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins const CFGBlock *PredBlock, const CFGBlock *CurrBlock, 9425381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins Expr *BrE, bool Neg); 9435381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 94454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const CallExpr* getTrylockCallExpr(const Stmt *Cond, LocalVarContext C, 94554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins bool &Negate); 946b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins 947a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins void getEdgeLockset(FactSet &Result, const FactSet &ExitSet, 948a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const CFGBlock* PredBlock, 949a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const CFGBlock *CurrBlock); 9500da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins 951a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins void intersectAndWarn(FactSet &FSet1, const FactSet &FSet2, 952a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins SourceLocation JoinLoc, 953a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LockErrorKind LEK1, LockErrorKind LEK2, 954a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins bool Modify=true); 955879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins 956a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins void intersectAndWarn(FactSet &FSet1, const FactSet &FSet2, 957a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins SourceLocation JoinLoc, LockErrorKind LEK1, 958a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins bool Modify=true) { 959a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins intersectAndWarn(FSet1, FSet2, JoinLoc, LEK1, LEK1, Modify); 960879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins } 961402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 96254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void runAnalysis(AnalysisDeclContext &AC); 963402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski}; 9643ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // namespace 9650e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 9660e2c34f92f00628d48968dfea096d36381f494cbStephen Hines/// Process acquired_before and acquired_after attributes on Vd. 9670e2c34f92f00628d48968dfea096d36381f494cbStephen HinesBeforeSet::BeforeInfo* BeforeSet::insertAttrExprs(const ValueDecl* Vd, 9680e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer& Analyzer) { 9690e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Create a new entry for Vd. 97087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo *Info = nullptr; 97187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar { 97287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // Keep InfoPtr in its own scope in case BMap is modified later and the 97387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // reference becomes invalid. 97487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar std::unique_ptr<BeforeInfo> &InfoPtr = BMap[Vd]; 97587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (!InfoPtr) 97687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar InfoPtr.reset(new BeforeInfo()); 97787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Info = InfoPtr.get(); 97887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar } 9790e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 9800e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (Attr* At : Vd->attrs()) { 9810e2c34f92f00628d48968dfea096d36381f494cbStephen Hines switch (At->getKind()) { 9820e2c34f92f00628d48968dfea096d36381f494cbStephen Hines case attr::AcquiredBefore: { 9830e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto *A = cast<AcquiredBeforeAttr>(At); 9840e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 9850e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Read exprs from the attribute, and add them to BeforeVect. 9860e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (const auto *Arg : A->args()) { 9870e2c34f92f00628d48968dfea096d36381f494cbStephen Hines CapabilityExpr Cp = 9880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr); 9890e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (const ValueDecl *Cpvd = Cp.valueDecl()) { 99087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Info->Vect.push_back(Cpvd); 9910e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto It = BMap.find(Cpvd); 9920e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (It == BMap.end()) 9930e2c34f92f00628d48968dfea096d36381f494cbStephen Hines insertAttrExprs(Cpvd, Analyzer); 9940e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 9950e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 9960e2c34f92f00628d48968dfea096d36381f494cbStephen Hines break; 9970e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 9980e2c34f92f00628d48968dfea096d36381f494cbStephen Hines case attr::AcquiredAfter: { 9990e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto *A = cast<AcquiredAfterAttr>(At); 10000e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10010e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Read exprs from the attribute, and add them to BeforeVect. 10020e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (const auto *Arg : A->args()) { 10030e2c34f92f00628d48968dfea096d36381f494cbStephen Hines CapabilityExpr Cp = 10040e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Analyzer.SxBuilder.translateAttrExpr(Arg, nullptr); 10050e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (const ValueDecl *ArgVd = Cp.valueDecl()) { 10060e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Get entry for mutex listed in attribute 100787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo *ArgInfo = getBeforeInfoForDecl(ArgVd, Analyzer); 100887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ArgInfo->Vect.push_back(Vd); 10090e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10100e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10110e2c34f92f00628d48968dfea096d36381f494cbStephen Hines break; 10120e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10130e2c34f92f00628d48968dfea096d36381f494cbStephen Hines default: 10140e2c34f92f00628d48968dfea096d36381f494cbStephen Hines break; 10150e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10160e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10170e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10180e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return Info; 10190e2c34f92f00628d48968dfea096d36381f494cbStephen Hines} 10200e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 102187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga NainarBeforeSet::BeforeInfo * 102287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga NainarBeforeSet::getBeforeInfoForDecl(const ValueDecl *Vd, 102387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ThreadSafetyAnalyzer &Analyzer) { 102487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar auto It = BMap.find(Vd); 102587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeInfo *Info = nullptr; 102687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (It == BMap.end()) 102787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Info = insertAttrExprs(Vd, Analyzer); 102887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar else 102987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Info = It->second.get(); 103087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar assert(Info && "BMap contained nullptr?"); 103187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return Info; 103287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar} 10330e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10340e2c34f92f00628d48968dfea096d36381f494cbStephen Hines/// Return true if any mutexes in FSet are in the acquired_before set of Vd. 10350e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesvoid BeforeSet::checkBeforeAfter(const ValueDecl* StartVd, 10360e2c34f92f00628d48968dfea096d36381f494cbStephen Hines const FactSet& FSet, 10370e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer& Analyzer, 10380e2c34f92f00628d48968dfea096d36381f494cbStephen Hines SourceLocation Loc, StringRef CapKind) { 10390e2c34f92f00628d48968dfea096d36381f494cbStephen Hines SmallVector<BeforeInfo*, 8> InfoVect; 10400e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10410e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Do a depth-first traversal of Vd. 10420e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Return true if there are cycles. 10430e2c34f92f00628d48968dfea096d36381f494cbStephen Hines std::function<bool (const ValueDecl*)> traverse = [&](const ValueDecl* Vd) { 10440e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (!Vd) 10450e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return false; 10460e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 104787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar BeforeSet::BeforeInfo *Info = getBeforeInfoForDecl(Vd, Analyzer); 10480e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10490e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (Info->Visited == 1) 10500e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return true; 10510e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10520e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (Info->Visited == 2) 10530e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return false; 10540e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 105587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (Info->Vect.empty()) 10560e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return false; 10570e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10580e2c34f92f00628d48968dfea096d36381f494cbStephen Hines InfoVect.push_back(Info); 10590e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Info->Visited = 1; 106087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar for (auto *Vdb : Info->Vect) { 10610e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Exclude mutexes in our immediate before set. 10620e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (FSet.containsMutexDecl(Analyzer.FactMan, Vdb)) { 10630e2c34f92f00628d48968dfea096d36381f494cbStephen Hines StringRef L1 = StartVd->getName(); 10640e2c34f92f00628d48968dfea096d36381f494cbStephen Hines StringRef L2 = Vdb->getName(); 10650e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Analyzer.Handler.handleLockAcquiredBefore(CapKind, L1, L2, Loc); 10660e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10670e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Transitively search other before sets, and warn on cycles. 10680e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (traverse(Vdb)) { 10690e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (CycMap.find(Vd) == CycMap.end()) { 10700e2c34f92f00628d48968dfea096d36381f494cbStephen Hines CycMap.insert(std::make_pair(Vd, true)); 10710e2c34f92f00628d48968dfea096d36381f494cbStephen Hines StringRef L1 = Vd->getName(); 10720e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Analyzer.Handler.handleBeforeAfterCycle(L1, Vd->getLocation()); 10730e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10740e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10750e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 10760e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Info->Visited = 2; 10770e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return false; 10780e2c34f92f00628d48968dfea096d36381f494cbStephen Hines }; 10790e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10800e2c34f92f00628d48968dfea096d36381f494cbStephen Hines traverse(StartVd); 10810e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10820e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (auto* Info : InfoVect) 10830e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Info->Visited = 0; 10840e2c34f92f00628d48968dfea096d36381f494cbStephen Hines} 10850e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10860e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 10870e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 1088651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines/// \brief Gets the value decl pointer from DeclRefExprs or MemberExprs. 1089651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesstatic const ValueDecl *getValueDecl(const Expr *Exp) { 1090651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *CE = dyn_cast<ImplicitCastExpr>(Exp)) 1091651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return getValueDecl(CE->getSubExpr()); 1092651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1093651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *DR = dyn_cast<DeclRefExpr>(Exp)) 1094651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return DR->getDecl(); 1095651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1096651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *ME = dyn_cast<MemberExpr>(Exp)) 1097651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ME->getMemberDecl(); 1098651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1099651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return nullptr; 1100651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1101651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 11023ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace { 1103651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinestemplate <typename Ty> 11046bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesclass has_arg_iterator_range { 1105651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef char yes[1]; 1106651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines typedef char no[2]; 1107651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1108651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <typename Inner> 11096bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines static yes& test(Inner *I, decltype(I->args()) * = nullptr); 1110651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1111651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines template <typename> 1112651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines static no& test(...); 1113651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1114651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinespublic: 1115651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes); 1116651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines}; 11173ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // namespace 1118651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1119651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesstatic StringRef ClassifyDiagnostic(const CapabilityAttr *A) { 1120651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return A->getName(); 1121651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1122651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1123651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesstatic StringRef ClassifyDiagnostic(QualType VDT) { 1124651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // We need to look at the declaration of the type of the value to determine 1125651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // which it is. The type should either be a record or a typedef, or a pointer 1126651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // or reference thereof. 1127651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *RT = VDT->getAs<RecordType>()) { 1128651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *RD = RT->getDecl()) 1129651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *CA = RD->getAttr<CapabilityAttr>()) 1130651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(CA); 1131651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } else if (const auto *TT = VDT->getAs<TypedefType>()) { 1132651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *TD = TT->getDecl()) 1133651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const auto *CA = TD->getAttr<CapabilityAttr>()) 1134651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(CA); 1135651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } else if (VDT->isPointerType() || VDT->isReferenceType()) 1136651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(VDT->getPointeeType()); 1137651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1138651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return "mutex"; 1139651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1140651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1141651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesstatic StringRef ClassifyDiagnostic(const ValueDecl *VD) { 1142651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines assert(VD && "No ValueDecl passed"); 1143651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1144651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // The ValueDecl is the declaration of a mutex or role (hopefully). 1145651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(VD->getType()); 1146651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1147651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1148651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinestemplate <typename AttrTy> 11496bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesstatic typename std::enable_if<!has_arg_iterator_range<AttrTy>::value, 1150651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef>::type 1151651f13cea278ec967336033dd032faef0e9fc2ecStephen HinesClassifyDiagnostic(const AttrTy *A) { 1152651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const ValueDecl *VD = getValueDecl(A->getArg())) 1153651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(VD); 1154651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return "mutex"; 1155651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 1156651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1157651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinestemplate <typename AttrTy> 11586bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesstatic typename std::enable_if<has_arg_iterator_range<AttrTy>::value, 1159651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef>::type 1160651f13cea278ec967336033dd032faef0e9fc2ecStephen HinesClassifyDiagnostic(const AttrTy *A) { 11616bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *Arg : A->args()) { 11626bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const ValueDecl *VD = getValueDecl(Arg)) 1163651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return ClassifyDiagnostic(VD); 1164651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 1165651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return "mutex"; 1166651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines} 116754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 1168176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1169176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesinline bool ThreadSafetyAnalyzer::inCurrentScope(const CapabilityExpr &CapE) { 1170176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!CurrentMethod) 1171176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return false; 1172176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (auto *P = dyn_cast_or_null<til::Project>(CapE.sexpr())) { 1173176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines auto *VD = P->clangDecl(); 1174176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (VD) 1175176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return VD->getDeclContext() == CurrentMethod->getDeclContext(); 1176176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1177176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return false; 1178176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines} 1179176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1180176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1181402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \brief Add a new lock to the lockset, warning if the lock is already there. 1182176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// \param ReqAttr -- true if this is part of an initial Requires attribute. 1183176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid ThreadSafetyAnalyzer::addLock(FactSet &FSet, 1184176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines std::unique_ptr<FactEntry> Entry, 1185176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind, bool ReqAttr) { 1186176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Entry->shouldIgnore()) 11874e4c15765d5f097e21dcaa30f1a94481924340f7DeLesley Hutchins return; 11884e4c15765d5f097e21dcaa30f1a94481924340f7DeLesley Hutchins 1189176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!ReqAttr && !Entry->negative()) { 1190176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // look for the negative capability, and remove it from the fact set. 1191176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr NegC = !*Entry; 1192176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry *Nen = FSet.findLock(FactMan, NegC); 1193176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Nen) { 1194176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.removeLock(FactMan, NegC); 1195176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1196176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else { 1197176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (inCurrentScope(*Entry) && !Entry->asserted()) 1198176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleNegativeNotHeld(DiagKind, Entry->toString(), 1199176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines NegC.toString(), Entry->loc()); 1200176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1201176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1202176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 12030e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Check before/after constraints 12040e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (Handler.issueBetaWarnings() && 12050e2c34f92f00628d48968dfea096d36381f494cbStephen Hines !Entry->asserted() && !Entry->declared()) { 12060e2c34f92f00628d48968dfea096d36381f494cbStephen Hines GlobalBeforeSet->checkBeforeAfter(Entry->valueDecl(), FSet, *this, 12070e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Entry->loc(), DiagKind); 12080e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 12090e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 1210176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // FIXME: Don't always warn when we have support for reentrant locks. 1211176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FSet.findLock(FactMan, *Entry)) { 1212176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Entry->asserted()) 1213176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleDoubleLock(DiagKind, Entry->toString(), Entry->loc()); 121454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } else { 1215176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet.addLock(FactMan, std::move(Entry)); 121654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 121754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins} 121854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 121954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 1220402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \brief Remove a lock from the lockset, warning if the lock is not there. 1221402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \param UnlockLoc The source location of the unlock (only used in error msg) 1222176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid ThreadSafetyAnalyzer::removeLock(FactSet &FSet, const CapabilityExpr &Cp, 1223a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins SourceLocation UnlockLoc, 1224651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines bool FullyRemove, LockKind ReceivedKind, 1225651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef DiagKind) { 1226176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.shouldIgnore()) 12274e4c15765d5f097e21dcaa30f1a94481924340f7DeLesley Hutchins return; 12284e4c15765d5f097e21dcaa30f1a94481924340f7DeLesley Hutchins 1229176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry *LDat = FSet.findLock(FactMan, Cp); 123054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if (!LDat) { 1231176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleUnmatchedUnlock(DiagKind, Cp.toString(), UnlockLoc); 1232651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return; 1233651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 1234651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1235651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // Generic lock removal doesn't care about lock kind mismatches, but 1236651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // otherwise diagnose when the lock kinds are mismatched. 1237176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (ReceivedKind != LK_Generic && LDat->kind() != ReceivedKind) { 1238176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleIncorrectUnlockKind(DiagKind, Cp.toString(), 1239176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat->kind(), ReceivedKind, UnlockLoc); 124054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 1241a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 1242176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat->handleUnlock(FSet, FactMan, Cp, UnlockLoc, FullyRemove, Handler, 1243176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines DiagKind); 1244402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 1245402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1246c99a5d820ead4e4f1f4b4a8ab61007b8da0307e6DeLesley Hutchins 12475381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins/// \brief Extract the list of mutexIDs from the attribute on an expression, 12485381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins/// and push them onto Mtxs, discarding any duplicates. 1249a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchinstemplate <typename AttrType> 1250176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, 1251ef2388b10c41a9696d5d81f42ca79ff005fef7fcDeLesley Hutchins Expr *Exp, const NamedDecl *D, 1252ef2388b10c41a9696d5d81f42ca79ff005fef7fcDeLesley Hutchins VarDecl *SelfDecl) { 1253a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins if (Attr->args_size() == 0) { 1254a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins // The mutex held is the "this" object. 1255176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr Cp = SxBuilder.translateAttrExpr(nullptr, D, Exp, SelfDecl); 1256176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.isInvalid()) { 1257176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnInvalidLock(Handler, nullptr, D, Exp, ClassifyDiagnostic(Attr)); 1258176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return; 1259176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1260176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines //else 1261176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Cp.shouldIgnore()) 1262176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Mtxs.push_back_nodup(Cp); 12635381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins return; 1264a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins } 1265a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 12666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *Arg : Attr->args()) { 1267176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr Cp = SxBuilder.translateAttrExpr(Arg, D, Exp, SelfDecl); 1268176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.isInvalid()) { 1269176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnInvalidLock(Handler, nullptr, D, Exp, ClassifyDiagnostic(Attr)); 1270176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines continue; 1271176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1272176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines //else 1273176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Cp.shouldIgnore()) 1274176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Mtxs.push_back_nodup(Cp); 127554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 127654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins} 127754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 127854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 12795381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins/// \brief Extract the list of mutexIDs from a trylock attribute. If the 12805381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins/// trylock applies to the given edge, then push them onto Mtxs, discarding 12815381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins/// any duplicates. 128254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchinstemplate <class AttrType> 1283176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid ThreadSafetyAnalyzer::getMutexIDs(CapExprSet &Mtxs, AttrType *Attr, 12845381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins Expr *Exp, const NamedDecl *D, 12855381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins const CFGBlock *PredBlock, 12865381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins const CFGBlock *CurrBlock, 12875381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins Expr *BrE, bool Neg) { 128854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins // Find out which branch has the lock 12896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines bool branch = false; 12906bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (CXXBoolLiteralExpr *BLE = dyn_cast_or_null<CXXBoolLiteralExpr>(BrE)) 129154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins branch = BLE->getValue(); 12926bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines else if (IntegerLiteral *ILE = dyn_cast_or_null<IntegerLiteral>(BrE)) 129354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins branch = ILE->getValue().getBoolValue(); 12946bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 129554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins int branchnum = branch ? 0 : 1; 12966bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (Neg) 12976bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines branchnum = !branchnum; 129854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 129954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins // If we've taken the trylock branch, then add the lock 130054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins int i = 0; 130154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins for (CFGBlock::const_succ_iterator SI = PredBlock->succ_begin(), 130254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins SE = PredBlock->succ_end(); SI != SE && i < 2; ++SI, ++i) { 13036bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (*SI == CurrBlock && i == branchnum) 13045381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins getMutexIDs(Mtxs, Attr, Exp, D); 130554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 130654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins} 130754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 13083ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarstatic bool getStaticBooleanValue(Expr *E, bool &TCond) { 130913106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (isa<CXXNullPtrLiteralExpr>(E) || isa<GNUNullExpr>(E)) { 131013106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins TCond = false; 131113106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return true; 131213106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } else if (CXXBoolLiteralExpr *BLE = dyn_cast<CXXBoolLiteralExpr>(E)) { 131313106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins TCond = BLE->getValue(); 131413106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return true; 131513106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } else if (IntegerLiteral *ILE = dyn_cast<IntegerLiteral>(E)) { 131613106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins TCond = ILE->getValue().getBoolValue(); 131713106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return true; 131813106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } else if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) { 131913106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return getStaticBooleanValue(CE->getSubExpr(), TCond); 132013106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 132113106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return false; 132213106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins} 132313106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins 132413106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins 132554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins// If Cond can be traced back to a function call, return the call expression. 132654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins// The negate variable should be called with false, and will be set to true 132754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins// if the function call is negated, e.g. if (!mu.tryLock(...)) 132854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchinsconst CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond, 132954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LocalVarContext C, 133054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins bool &Negate) { 133154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if (!Cond) 13326bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 133354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 133454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if (const CallExpr *CallExp = dyn_cast<CallExpr>(Cond)) { 133554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins return CallExp; 133654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 133713106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins else if (const ParenExpr *PE = dyn_cast<ParenExpr>(Cond)) { 133813106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return getTrylockCallExpr(PE->getSubExpr(), C, Negate); 133913106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 134054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins else if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(Cond)) { 134154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins return getTrylockCallExpr(CE->getSubExpr(), C, Negate); 134254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 1343fd0f11ccd51154e933fad7dfa134cb4f62c87056DeLesley Hutchins else if (const ExprWithCleanups* EWC = dyn_cast<ExprWithCleanups>(Cond)) { 1344fd0f11ccd51154e933fad7dfa134cb4f62c87056DeLesley Hutchins return getTrylockCallExpr(EWC->getSubExpr(), C, Negate); 1345fd0f11ccd51154e933fad7dfa134cb4f62c87056DeLesley Hutchins } 134654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Cond)) { 134754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const Expr *E = LocalVarMap.lookupExpr(DRE->getDecl(), C); 134854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins return getTrylockCallExpr(E, C, Negate); 134954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 135054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins else if (const UnaryOperator *UOP = dyn_cast<UnaryOperator>(Cond)) { 135154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if (UOP->getOpcode() == UO_LNot) { 135254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Negate = !Negate; 135354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins return getTrylockCallExpr(UOP->getSubExpr(), C, Negate); 135454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 13556bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 135613106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 135713106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins else if (const BinaryOperator *BOP = dyn_cast<BinaryOperator>(Cond)) { 135813106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (BOP->getOpcode() == BO_EQ || BOP->getOpcode() == BO_NE) { 135913106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (BOP->getOpcode() == BO_NE) 136013106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins Negate = !Negate; 136113106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins 136213106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins bool TCond = false; 136313106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (getStaticBooleanValue(BOP->getRHS(), TCond)) { 136413106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (!TCond) Negate = !Negate; 136513106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return getTrylockCallExpr(BOP->getLHS(), C, Negate); 136613106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 13677336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins TCond = false; 13687336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins if (getStaticBooleanValue(BOP->getLHS(), TCond)) { 136913106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins if (!TCond) Negate = !Negate; 137013106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins return getTrylockCallExpr(BOP->getRHS(), C, Negate); 137113106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 13726bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 137313106117060c90d6f84bd2ed7a5c03e0502ff419DeLesley Hutchins } 13747336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins if (BOP->getOpcode() == BO_LAnd) { 13757336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins // LHS must have been evaluated in a different block. 13767336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins return getTrylockCallExpr(BOP->getRHS(), C, Negate); 13777336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins } 13787336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins if (BOP->getOpcode() == BO_LOr) { 13797336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins return getTrylockCallExpr(BOP->getRHS(), C, Negate); 13807336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins } 13816bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 138254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 13836bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 138454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins} 138554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 138654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 13870da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins/// \brief Find the lockset that holds on the edge between PredBlock 13880da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins/// and CurrBlock. The edge set is the exit set of PredBlock (passed 13890da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins/// as the ExitSet parameter) plus any trylocks, which are conditionally held. 1390a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsvoid ThreadSafetyAnalyzer::getEdgeLockset(FactSet& Result, 1391a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const FactSet &ExitSet, 1392a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const CFGBlock *PredBlock, 1393a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const CFGBlock *CurrBlock) { 1394a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins Result = ExitSet; 1395a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 13967336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins const Stmt *Cond = PredBlock->getTerminatorCondition(); 13977336b9f8c0b58550a74c85a64f06d0fd74e7ad0dDeLesley Hutchins if (!Cond) 1398a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return; 13990da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins 140054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins bool Negate = false; 140154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const CFGBlockInfo *PredBlockInfo = &BlockInfo[PredBlock->getBlockID()]; 140254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins const LocalVarContext &LVarCtx = PredBlockInfo->ExitContext; 1403651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef CapDiagKind = "mutex"; 140454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 14055381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins CallExpr *Exp = 14065381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins const_cast<CallExpr*>(getTrylockCallExpr(Cond, LVarCtx, Negate)); 140754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if (!Exp) 1408a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return; 140954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 141054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins NamedDecl *FunDecl = dyn_cast_or_null<NamedDecl>(Exp->getCalleeDecl()); 141154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins if(!FunDecl || !FunDecl->hasAttrs()) 1412a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins return; 141354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 1414176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet ExclusiveLocksToAdd; 1415176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet SharedLocksToAdd; 141654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 141754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins // If the condition is a call to a Trylock function, then grab the attributes 14180e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (auto *Attr : FunDecl->attrs()) { 141954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins switch (Attr->getKind()) { 142054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins case attr::ExclusiveTrylockFunction: { 142154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins ExclusiveTrylockFunctionAttr *A = 142254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins cast<ExclusiveTrylockFunctionAttr>(Attr); 14235381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins getMutexIDs(ExclusiveLocksToAdd, A, Exp, FunDecl, 14245381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins PredBlock, CurrBlock, A->getSuccessValue(), Negate); 1425651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 142654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins break; 142754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 142854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins case attr::SharedTrylockFunction: { 142954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins SharedTrylockFunctionAttr *A = 143054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins cast<SharedTrylockFunctionAttr>(Attr); 143160ff198a22815b0aec5b96eaae977de067dcd4c1DeLesley Hutchins getMutexIDs(SharedLocksToAdd, A, Exp, FunDecl, 14325381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins PredBlock, CurrBlock, A->getSuccessValue(), Negate); 1433651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 143454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins break; 143554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 143654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins default: 143754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins break; 143854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins } 1439f1ac63702143d84db778d32eb185a77fc97db5f5DeLesley Hutchins } 14405381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 14415381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins // Add and remove locks. 14425381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins SourceLocation Loc = Exp->getExprLoc(); 1443651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &ExclusiveLockToAdd : ExclusiveLocksToAdd) 1444176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines addLock(Result, llvm::make_unique<LockableFactEntry>(ExclusiveLockToAdd, 1445176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK_Exclusive, Loc), 1446651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind); 1447651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &SharedLockToAdd : SharedLocksToAdd) 1448176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines addLock(Result, llvm::make_unique<LockableFactEntry>(SharedLockToAdd, 1449176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK_Shared, Loc), 1450176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapDiagKind); 1451f1ac63702143d84db778d32eb185a77fc97db5f5DeLesley Hutchins} 1452f1ac63702143d84db778d32eb185a77fc97db5f5DeLesley Hutchins 14533ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarnamespace { 145454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins/// \brief We use this class to visit different types of expressions in 145554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins/// CFGBlocks, and build up the lockset. 145654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins/// An expression may cause us to add or remove locks from the lockset, or else 145754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins/// output error messages related to missing locks. 145854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins/// FIXME: In future, we may be able to not inherit from a visitor. 145954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchinsclass BuildLockset : public StmtVisitor<BuildLockset> { 146054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins friend class ThreadSafetyAnalyzer; 146154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 146254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins ThreadSafetyAnalyzer *Analyzer; 1463a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet FSet; 146454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LocalVariableMap::Context LVarCtx; 146554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins unsigned CtxIndex; 146654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 1467176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // helper functions 146847715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins void warnIfMutexNotHeld(const NamedDecl *D, const Expr *Exp, AccessKind AK, 1469651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Expr *MutexExp, ProtectedOperationKind POK, 1470176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind, SourceLocation Loc); 1471651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void warnIfMutexHeld(const NamedDecl *D, const Expr *Exp, Expr *MutexExp, 1472651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef DiagKind); 147347715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins 1474176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void checkAccess(const Expr *Exp, AccessKind AK, 1475176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ProtectedOperationKind POK = POK_VarAccess); 1476176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines void checkPtAccess(const Expr *Exp, AccessKind AK, 1477176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ProtectedOperationKind POK = POK_VarAccess); 147854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 14796bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines void handleCall(Expr *Exp, const NamedDecl *D, VarDecl *VD = nullptr); 148054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 148154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchinspublic: 148254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins BuildLockset(ThreadSafetyAnalyzer *Anlzr, CFGBlockInfo &Info) 148354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins : StmtVisitor<BuildLockset>(), 148454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Analyzer(Anlzr), 1485a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FSet(Info.EntrySet), 148654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LVarCtx(Info.EntryContext), 148754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins CtxIndex(Info.EntryIndex) 148854c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins {} 148954c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 149054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitUnaryOperator(UnaryOperator *UO); 149154c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitBinaryOperator(BinaryOperator *BO); 149254c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitCastExpr(CastExpr *CE); 149354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitCallExpr(CallExpr *Exp); 149454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitCXXConstructExpr(CXXConstructExpr *Exp); 149554c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins void VisitDeclStmt(DeclStmt *S); 149654c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins}; 14973ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar} // namespace 1498176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1499402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \brief Warn if the LSet does not contain a lock sufficient to protect access 15009f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins/// of at least the passed in AccessKind. 150147715cc201170952029a52806bcc26f69c38272dDeLesley Hutchinsvoid BuildLockset::warnIfMutexNotHeld(const NamedDecl *D, const Expr *Exp, 1502402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski AccessKind AK, Expr *MutexExp, 1503651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ProtectedOperationKind POK, 1504176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef DiagKind, SourceLocation Loc) { 1505402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski LockKind LK = getLockKindFromAccessKind(AK); 15069f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins 1507176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr Cp = Analyzer->SxBuilder.translateAttrExpr(MutexExp, D, Exp); 1508176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.isInvalid()) { 1509176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnInvalidLock(Analyzer->Handler, MutexExp, D, Exp, DiagKind); 15100b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins return; 1511176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } else if (Cp.shouldIgnore()) { 15120b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins return; 15130b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins } 15140b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins 1515176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.negative()) { 1516176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Negative capabilities act like locks excluded 1517176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry *LDat = FSet.findLock(Analyzer->FactMan, !Cp); 1518176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LDat) { 1519176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleFunExcludesLock( 1520176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines DiagKind, D->getNameAsString(), (!Cp).toString(), Loc); 1521176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return; 1522176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1523176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1524176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If this does not refer to a negative capability in the same class, 1525176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // then stop here. 1526176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!Analyzer->inCurrentScope(Cp)) 1527176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return; 1528176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1529176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Otherwise the negative requirement must be propagated to the caller. 1530176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat = FSet.findLock(Analyzer->FactMan, Cp); 1531176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!LDat) { 1532176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleMutexNotHeld("", D, POK, Cp.toString(), 1533176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK_Shared, Loc); 1534176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1535176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return; 1536176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1537176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1538176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry* LDat = FSet.findLockUniv(Analyzer->FactMan, Cp); 15393f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins bool NoError = true; 15403f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins if (!LDat) { 15413f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins // No exact match found. Look for a partial match. 1542176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat = FSet.findPartialMatch(Analyzer->FactMan, Cp); 1543176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LDat) { 15443f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins // Warn that there's no precise match. 1545176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines std::string PartMatchStr = LDat->toString(); 15463f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins StringRef PartMatchName(PartMatchStr); 1547176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleMutexNotHeld(DiagKind, D, POK, Cp.toString(), 1548176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK, Loc, &PartMatchName); 15493f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins } else { 15503f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins // Warn that there's no match at all. 1551176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleMutexNotHeld(DiagKind, D, POK, Cp.toString(), 1552176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK, Loc); 15533f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins } 15543f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins NoError = false; 15553f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins } 15563f0ec5209726641782468bd4c7597e79dda78b15DeLesley Hutchins // Make sure the mutex we found is the right kind. 1557176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (NoError && LDat && !LDat->isAtLeast(LK)) { 1558176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleMutexNotHeld(DiagKind, D, POK, Cp.toString(), 1559176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LK, Loc); 1560176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1561402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 1562402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 15630b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins/// \brief Warn if the LSet contains the given lock. 1564651f13cea278ec967336033dd032faef0e9fc2ecStephen Hinesvoid BuildLockset::warnIfMutexHeld(const NamedDecl *D, const Expr *Exp, 1565176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Expr *MutexExp, StringRef DiagKind) { 1566176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr Cp = Analyzer->SxBuilder.translateAttrExpr(MutexExp, D, Exp); 1567176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Cp.isInvalid()) { 1568176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnInvalidLock(Analyzer->Handler, MutexExp, D, Exp, DiagKind); 1569176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return; 1570176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } else if (Cp.shouldIgnore()) { 15710b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins return; 15720b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins } 15730b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins 1574176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactEntry* LDat = FSet.findLock(Analyzer->FactMan, Cp); 1575176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LDat) { 1576651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->Handler.handleFunExcludesLock( 1577176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines DiagKind, D->getNameAsString(), Cp.toString(), Exp->getExprLoc()); 1578176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 15790b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins} 15800b4db3e08a201c35f0011489bd5cd5d39bbe54fbDeLesley Hutchins 158147715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// \brief Checks guarded_by and pt_guarded_by attributes. 158247715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// Whenever we identify an access (read or write) to a DeclRefExpr that is 158347715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// marked with guarded_by, we must ensure the appropriate mutexes are held. 158447715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// Similarly, we check if the access is to an expression that dereferences 158547715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// a pointer marked with pt_guarded_by. 1586176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid BuildLockset::checkAccess(const Expr *Exp, AccessKind AK, 1587176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ProtectedOperationKind POK) { 158847715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins Exp = Exp->IgnoreParenCasts(); 158947715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins 1590176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines SourceLocation Loc = Exp->getExprLoc(); 1591176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1592176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Local variables of reference type cannot be re-assigned; 1593176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // map them to their initializer. 1594176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines while (const auto *DRE = dyn_cast<DeclRefExpr>(Exp)) { 1595176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()->getCanonicalDecl()); 1596176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (VD && VD->isLocalVarDecl() && VD->getType()->isReferenceType()) { 1597176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (const auto *E = VD->getInit()) { 1598176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Exp = E; 1599176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines continue; 1600176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1601176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1602176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines break; 1603176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1604176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 160547715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Exp)) { 160647715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins // For dereferences 160747715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins if (UO->getOpcode() == clang::UO_Deref) 1608176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkPtAccess(UO->getSubExpr(), AK, POK); 1609402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski return; 161047715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins } 1611402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1612f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins if (const ArraySubscriptExpr *AE = dyn_cast<ArraySubscriptExpr>(Exp)) { 1613176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkPtAccess(AE->getLHS(), AK, POK); 1614651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return; 1615f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins } 1616f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins 1617dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (const MemberExpr *ME = dyn_cast<MemberExpr>(Exp)) { 1618dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (ME->isArrow()) 1619176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkPtAccess(ME->getBase(), AK, POK); 1620dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins else 1621176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkAccess(ME->getBase(), AK, POK); 162293699d23cd07c021eac2e26f8e32b58276bfa912DeLesley Hutchins } 162393699d23cd07c021eac2e26f8e32b58276bfa912DeLesley Hutchins 1624402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski const ValueDecl *D = getValueDecl(Exp); 162547715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins if (!D || !D->hasAttrs()) 1626402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski return; 1627402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1628176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (D->hasAttr<GuardedVarAttr>() && FSet.isEmpty(Analyzer->FactMan)) { 1629176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleNoMutexHeld("mutex", D, POK, AK, Loc); 1630176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1631402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1632651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto *I : D->specific_attrs<GuardedByAttr>()) 1633176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnIfMutexNotHeld(D, Exp, AK, I->getArg(), POK, 1634176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ClassifyDiagnostic(I), Loc); 1635402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 1636402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1637176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 163847715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins/// \brief Checks pt_guarded_by and pt_guarded_var attributes. 1639176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// POK is the same operationKind that was passed to checkAccess. 1640176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesvoid BuildLockset::checkPtAccess(const Expr *Exp, AccessKind AK, 1641176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ProtectedOperationKind POK) { 1642651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines while (true) { 1643651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const ParenExpr *PE = dyn_cast<ParenExpr>(Exp)) { 1644651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Exp = PE->getSubExpr(); 1645651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines continue; 1646651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines } 1647651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (const CastExpr *CE = dyn_cast<CastExpr>(Exp)) { 1648651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (CE->getCastKind() == CK_ArrayToPointerDecay) { 1649651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // If it's an actual array, and not a pointer, then it's elements 1650651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // are protected by GUARDED_BY, not PT_GUARDED_BY; 1651176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkAccess(CE->getSubExpr(), AK, POK); 1652651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines return; 1653f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins } 1654651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Exp = CE->getSubExpr(); 1655651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines continue; 1656f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins } 1657651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines break; 1658f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins } 165947715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins 1660176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Pass by reference warnings are under a different flag. 1661176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ProtectedOperationKind PtPOK = POK_VarDereference; 1662176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (POK == POK_PassByRef) PtPOK = POK_PtPassByRef; 1663176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1664402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski const ValueDecl *D = getValueDecl(Exp); 166547715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins if (!D || !D->hasAttrs()) 1666402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski return; 1667402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1668176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (D->hasAttr<PtGuardedVarAttr>() && FSet.isEmpty(Analyzer->FactMan)) 1669176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->Handler.handleNoMutexHeld("mutex", D, PtPOK, AK, 167054c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins Exp->getExprLoc()); 1671402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1672651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (auto const *I : D->specific_attrs<PtGuardedByAttr>()) 1673176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines warnIfMutexNotHeld(D, Exp, AK, I->getArg(), PtPOK, 1674176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ClassifyDiagnostic(I), Exp->getExprLoc()); 1675402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 1676402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1677e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// \brief Process a function call, method call, constructor call, 1678e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// or destructor call. This involves looking at the attributes on the 1679e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// corresponding function/method/constructor/destructor, issuing warnings, 1680e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// and updating the locksets accordingly. 1681402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// 1682402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// FIXME: For classes annotated with one of the guarded annotations, we need 1683402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// to treat const method calls as reads and non-const method calls as writes, 1684402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// and check that the appropriate locks are held. Non-const method calls with 1685402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// the same signature as const method calls can be also treated as reads. 1686402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// 16875381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchinsvoid BuildLockset::handleCall(Expr *Exp, const NamedDecl *D, VarDecl *VD) { 16885c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins SourceLocation Loc = Exp->getExprLoc(); 1689176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet ExclusiveLocksToAdd, SharedLocksToAdd; 1690176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet ExclusiveLocksToRemove, SharedLocksToRemove, GenericLocksToRemove; 16910e2c34f92f00628d48968dfea096d36381f494cbStephen Hines CapExprSet ScopedExclusiveReqs, ScopedSharedReqs; 1692651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef CapDiagKind = "mutex"; 16935381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 16940e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // Figure out if we're calling the constructor of scoped lockable class 16950e2c34f92f00628d48968dfea096d36381f494cbStephen Hines bool isScopedVar = false; 16960e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (VD) { 16970e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (const CXXConstructorDecl *CD = dyn_cast<const CXXConstructorDecl>(D)) { 16980e2c34f92f00628d48968dfea096d36381f494cbStephen Hines const CXXRecordDecl* PD = CD->getParent(); 16990e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (PD && PD->hasAttr<ScopedLockableAttr>()) 17000e2c34f92f00628d48968dfea096d36381f494cbStephen Hines isScopedVar = true; 17010e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 17020e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 17030e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 17040e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for(Attr *Atconst : D->attrs()) { 17050e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Attr* At = const_cast<Attr*>(Atconst); 17065381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins switch (At->getKind()) { 1707651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // When we encounter a lock function, we need to add the lock to our 1708651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // lockset. 1709651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines case attr::AcquireCapability: { 1710651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines auto *A = cast<AcquireCapabilityAttr>(At); 1711651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->getMutexIDs(A->isShared() ? SharedLocksToAdd 1712651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines : ExclusiveLocksToAdd, 1713651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines A, Exp, D, VD); 1714651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 1715651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 1716402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski break; 17179f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins } 1718402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 17195c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins // An assert will add a lock to the lockset, but will not generate 17205c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins // a warning if it is already there, and will not generate a warning 17215c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins // if it is not removed. 17225c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins case attr::AssertExclusiveLock: { 17235c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins AssertExclusiveLockAttr *A = cast<AssertExclusiveLockAttr>(At); 17245c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins 1725176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet AssertLocks; 17265c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins Analyzer->getMutexIDs(AssertLocks, A, Exp, D, VD); 1727651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &AssertLock : AssertLocks) 1728176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->addLock(FSet, 1729176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::make_unique<LockableFactEntry>( 1730176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines AssertLock, LK_Exclusive, Loc, false, true), 1731651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ClassifyDiagnostic(A)); 17325c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins break; 17335c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins } 17345c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins case attr::AssertSharedLock: { 17355c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins AssertSharedLockAttr *A = cast<AssertSharedLockAttr>(At); 17365c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins 1737176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet AssertLocks; 17385c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins Analyzer->getMutexIDs(AssertLocks, A, Exp, D, VD); 1739651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &AssertLock : AssertLocks) 1740176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->addLock(FSet, llvm::make_unique<LockableFactEntry>( 1741176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines AssertLock, LK_Shared, Loc, false, true), 1742651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines ClassifyDiagnostic(A)); 17435c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins break; 17445c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins } 17455c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins 1746402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // When we encounter an unlock function, we need to remove unlocked 1747402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // mutexes from the lockset, and flag a warning if they are not there. 1748651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines case attr::ReleaseCapability: { 1749651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines auto *A = cast<ReleaseCapabilityAttr>(At); 1750651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (A->isGeneric()) 1751651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->getMutexIDs(GenericLocksToRemove, A, Exp, D, VD); 1752651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines else if (A->isShared()) 1753651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->getMutexIDs(SharedLocksToRemove, A, Exp, D, VD); 1754651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines else 1755651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->getMutexIDs(ExclusiveLocksToRemove, A, Exp, D, VD); 1756402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1757651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 1758402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski break; 1759402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 1760402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1761651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines case attr::RequiresCapability: { 1762651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines RequiresCapabilityAttr *A = cast<RequiresCapabilityAttr>(At); 17630e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (auto *Arg : A->args()) { 17646bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines warnIfMutexNotHeld(D, Exp, A->isShared() ? AK_Read : AK_Written, Arg, 1765176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines POK_FunctionCall, ClassifyDiagnostic(A), 1766176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Exp->getExprLoc()); 17670e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // use for adopting a lock 17680e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (isScopedVar) { 17690e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Analyzer->getMutexIDs(A->isShared() ? ScopedSharedReqs 17700e2c34f92f00628d48968dfea096d36381f494cbStephen Hines : ScopedExclusiveReqs, 17710e2c34f92f00628d48968dfea096d36381f494cbStephen Hines A, Exp, D, VD); 17720e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 17730e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 1774402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski break; 1775402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 1776402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1777402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski case attr::LocksExcluded: { 17785381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins LocksExcludedAttr *A = cast<LocksExcludedAttr>(At); 17796bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (auto *Arg : A->args()) 17806bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines warnIfMutexHeld(D, Exp, Arg, ClassifyDiagnostic(A)); 1781402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski break; 1782402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 1783402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1784651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines // Ignore attributes unrelated to thread-safety 1785402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski default: 1786402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski break; 1787402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 1788402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 17895381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 17905381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins // Add locks. 1791651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &M : ExclusiveLocksToAdd) 1792176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->addLock(FSet, llvm::make_unique<LockableFactEntry>( 1793176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines M, LK_Exclusive, Loc, isScopedVar), 1794651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind); 1795651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &M : SharedLocksToAdd) 1796176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->addLock(FSet, llvm::make_unique<LockableFactEntry>( 1797176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines M, LK_Shared, Loc, isScopedVar), 1798651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind); 17995381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 18005381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins if (isScopedVar) { 1801176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Add the managing object as a dummy mutex, mapped to the underlying mutex. 18025381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins SourceLocation MLoc = VD->getLocation(); 18035381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins DeclRefExpr DRE(VD, false, VD->getType(), VK_LValue, VD->getLocation()); 1804176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // FIXME: does this store a pointer to DRE? 1805176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapabilityExpr Scp = Analyzer->SxBuilder.translateAttrExpr(&DRE, nullptr); 1806176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 18070e2c34f92f00628d48968dfea096d36381f494cbStephen Hines std::copy(ScopedExclusiveReqs.begin(), ScopedExclusiveReqs.end(), 18080e2c34f92f00628d48968dfea096d36381f494cbStephen Hines std::back_inserter(ExclusiveLocksToAdd)); 18090e2c34f92f00628d48968dfea096d36381f494cbStephen Hines std::copy(ScopedSharedReqs.begin(), ScopedSharedReqs.end(), 18100e2c34f92f00628d48968dfea096d36381f494cbStephen Hines std::back_inserter(SharedLocksToAdd)); 1811176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Analyzer->addLock(FSet, 1812176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::make_unique<ScopedLockableFactEntry>( 1813176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Scp, MLoc, ExclusiveLocksToAdd, SharedLocksToAdd), 1814176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapDiagKind); 18155381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins } 18165381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 18175381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins // Remove locks. 18185381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins // FIXME -- should only fully remove if the attribute refers to 'this'. 18195381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins bool Dtor = isa<CXXDestructorDecl>(D); 1820651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &M : ExclusiveLocksToRemove) 1821651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->removeLock(FSet, M, Loc, Dtor, LK_Exclusive, CapDiagKind); 1822651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &M : SharedLocksToRemove) 1823651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->removeLock(FSet, M, Loc, Dtor, LK_Shared, CapDiagKind); 1824651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines for (const auto &M : GenericLocksToRemove) 1825651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Analyzer->removeLock(FSet, M, Loc, Dtor, LK_Generic, CapDiagKind); 1826402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 1827402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 1828b4fa418a72759dfe34add850837965cbc00626e4DeLesley Hutchins 1829e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// \brief For unary operations which read and write a variable, we need to 1830e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// check whether we hold any required mutexes. Reads are checked in 1831e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// VisitCastExpr. 1832e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchinsvoid BuildLockset::VisitUnaryOperator(UnaryOperator *UO) { 1833e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins switch (UO->getOpcode()) { 1834e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins case clang::UO_PostDec: 1835e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins case clang::UO_PostInc: 1836e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins case clang::UO_PreDec: 1837e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins case clang::UO_PreInc: { 183847715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins checkAccess(UO->getSubExpr(), AK_Written); 1839e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins break; 1840e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins } 1841e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins default: 1842e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins break; 1843e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins } 1844e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins} 1845e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 1846e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// For binary operations which assign to a variable (writes), we need to check 1847e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// whether we hold any required mutexes. 1848e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// FIXME: Deal with non-primitive types. 1849e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchinsvoid BuildLockset::VisitBinaryOperator(BinaryOperator *BO) { 1850e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins if (!BO->isAssignmentOp()) 1851e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins return; 1852b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 1853b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // adjust the context 185454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LVarCtx = Analyzer->LocalVarMap.getNextContext(CtxIndex, BO, LVarCtx); 1855b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 185647715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins checkAccess(BO->getLHS(), AK_Written); 1857e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins} 1858e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 1859f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins 1860e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// Whenever we do an LValue to Rvalue cast, we are reading a variable and 1861e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// need to ensure we hold any required mutexes. 1862e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins/// FIXME: Deal with non-primitive types. 1863e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchinsvoid BuildLockset::VisitCastExpr(CastExpr *CE) { 1864e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins if (CE->getCastKind() != CK_LValueToRValue) 1865e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins return; 186647715cc201170952029a52806bcc26f69c38272dDeLesley Hutchins checkAccess(CE->getSubExpr(), AK_Read); 1867e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins} 1868e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 1869e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 1870df49782c54802ca1a4c1d36d66186aa039f32aecDeLesley Hutchinsvoid BuildLockset::VisitCallExpr(CallExpr *Exp) { 1871176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool ExamineArgs = true; 1872176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines bool OperatorFun = false; 1873176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1874dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(Exp)) { 1875dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins MemberExpr *ME = dyn_cast<MemberExpr>(CE->getCallee()); 1876dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins // ME can be null when calling a method pointer 1877dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins CXXMethodDecl *MD = CE->getMethodDecl(); 1878dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins 1879dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (ME && MD) { 1880dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (ME->isArrow()) { 1881dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (MD->isConst()) { 1882dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkPtAccess(CE->getImplicitObjectArgument(), AK_Read); 1883dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins } else { // FIXME -- should be AK_Written 1884dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkPtAccess(CE->getImplicitObjectArgument(), AK_Read); 188591e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 1886dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins } else { 1887dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (MD->isConst()) 1888dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkAccess(CE->getImplicitObjectArgument(), AK_Read); 1889dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins else // FIXME -- should be AK_Written 1890dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkAccess(CE->getImplicitObjectArgument(), AK_Read); 189191e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 1892dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins } 1893dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins } else if (CXXOperatorCallExpr *OE = dyn_cast<CXXOperatorCallExpr>(Exp)) { 1894176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines OperatorFun = true; 1895176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1896176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines auto OEop = OE->getOperator(); 1897176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines switch (OEop) { 1898dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins case OO_Equal: { 1899176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ExamineArgs = false; 1900dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins const Expr *Target = OE->getArg(0); 1901dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins const Expr *Source = OE->getArg(1); 1902dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkAccess(Target, AK_Written); 1903dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkAccess(Source, AK_Read); 1904dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins break; 1905dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins } 190643399fb0e79687043b7904195e95a23e44bd6ca1DeLesley Hutchins case OO_Star: 1907f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins case OO_Arrow: 1908f9495911c46a5f90d8cf14774c11ff521d505c7eDeLesley Hutchins case OO_Subscript: { 1909651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines const Expr *Obj = OE->getArg(0); 1910651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines checkAccess(Obj, AK_Read); 1911176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!(OEop == OO_Star && OE->getNumArgs() > 1)) { 1912176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Grrr. operator* can be multiplication... 1913176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines checkPtAccess(Obj, AK_Read); 1914176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 191543399fb0e79687043b7904195e95a23e44bd6ca1DeLesley Hutchins break; 191643399fb0e79687043b7904195e95a23e44bd6ca1DeLesley Hutchins } 1917dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins default: { 1918176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // TODO: get rid of this, and rely on pass-by-ref instead. 19199a2f84b2f03e79fb21f9db9e029045fba09dedefDeLesley Hutchins const Expr *Obj = OE->getArg(0); 19209a2f84b2f03e79fb21f9db9e029045fba09dedefDeLesley Hutchins checkAccess(Obj, AK_Read); 1921dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins break; 192291e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 192391e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 192491e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 1925176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1926176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (ExamineArgs) { 1927176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (FunctionDecl *FD = Exp->getDirectCallee()) { 192887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 192987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // NO_THREAD_SAFETY_ANALYSIS does double duty here. Normally it 193087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // only turns off checking within the body of a function, but we also 193187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // use it to turn off checking in arguments to the function. This 193287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // could result in some false negatives, but the alternative is to 193387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // create yet another attribute. 193487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // 193587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (!FD->hasAttr<NoThreadSafetyAnalysisAttr>()) { 193687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar unsigned Fn = FD->getNumParams(); 193787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar unsigned Cn = Exp->getNumArgs(); 193887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar unsigned Skip = 0; 193987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 194087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar unsigned i = 0; 194187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (OperatorFun) { 194287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (isa<CXXMethodDecl>(FD)) { 194387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // First arg in operator call is implicit self argument, 194487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // and doesn't appear in the FunctionDecl. 194587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Skip = 1; 194687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Cn--; 194787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar } else { 194887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // Ignore the first argument of operators; it's been checked above. 194987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar i = 1; 195087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar } 195187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar } 195287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // Ignore default arguments 195387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar unsigned n = (Fn < Cn) ? Fn : Cn; 195487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 195587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar for (; i < n; ++i) { 195687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ParmVarDecl* Pvd = FD->getParamDecl(i); 195787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Expr* Arg = Exp->getArg(i+Skip); 195887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType Qt = Pvd->getType(); 195987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (Qt->isReferenceType()) 196087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar checkAccess(Arg, AK_Read, POK_PassByRef); 1961176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1962176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1963176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1964176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 1965176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 1966e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins NamedDecl *D = dyn_cast_or_null<NamedDecl>(Exp->getCalleeDecl()); 1967e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins if(!D || !D->hasAttrs()) 1968e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins return; 1969e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins handleCall(Exp, D); 1970e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins} 1971e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 1972e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchinsvoid BuildLockset::VisitCXXConstructExpr(CXXConstructExpr *Exp) { 1973dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins const CXXConstructorDecl *D = Exp->getConstructor(); 1974dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins if (D && D->isCopyConstructor()) { 1975dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins const Expr* Source = Exp->getArg(0); 1976dd0a1f58a505ced9674f6d31a1ff65cb87774d67DeLesley Hutchins checkAccess(Source, AK_Read); 197791e2061763f5e59f57e59c6f141b74b5ff0408adDeLesley Hutchins } 19781fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins // FIXME -- only handles constructors in DeclStmt below. 19791fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins} 19801fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins 19811fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchinsvoid BuildLockset::VisitDeclStmt(DeclStmt *S) { 1982b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // adjust the context 198354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins LVarCtx = Analyzer->LocalVarMap.getNextContext(CtxIndex, S, LVarCtx); 1984b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 19856bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (auto *D : S->getDeclGroup()) { 19861fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins if (VarDecl *VD = dyn_cast_or_null<VarDecl>(D)) { 19871fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins Expr *E = VD->getInit(); 19889d6e7f3e12f1a825377ace33161e80caeda8cd06DeLesley Hutchins // handle constructors that involve temporaries 19899d6e7f3e12f1a825377ace33161e80caeda8cd06DeLesley Hutchins if (ExprWithCleanups *EWC = dyn_cast_or_null<ExprWithCleanups>(E)) 19909d6e7f3e12f1a825377ace33161e80caeda8cd06DeLesley Hutchins E = EWC->getSubExpr(); 19919d6e7f3e12f1a825377ace33161e80caeda8cd06DeLesley Hutchins 19921fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins if (CXXConstructExpr *CE = dyn_cast_or_null<CXXConstructExpr>(E)) { 19931fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins NamedDecl *CtorD = dyn_cast_or_null<NamedDecl>(CE->getConstructor()); 19941fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins if (!CtorD || !CtorD->hasAttrs()) 19951fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins return; 19961fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins handleCall(CE, CtorD, VD); 19971fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins } 19981fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins } 19991fa3c0682a52c45c4ad0be3a82d0c85f26657072DeLesley Hutchins } 2000e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins} 2001e0eaa8531f8fd9189710aac3b6f3aadb62bb14d1DeLesley Hutchins 2002a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 20030da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins 20044e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// \brief Compute the intersection of two locksets and issue warnings for any 20054e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// locks in the symmetric difference. 20064e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// 20074e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// This function is used at a merge point in the CFG when comparing the lockset 20084e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// of each branch being merged. For example, given the following sequence: 20094e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// A; if () then B; else C; D; we need to check that the lockset after B and C 20104e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// are the same. In the event of a difference, we use the intersection of these 20114e4bc75d3570835e13183c66ac08974cdc016007Caitlin Sadowski/// two locksets at the start of D. 20120da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins/// 2013ad0fe03b897f9486191e75c8d90c3ffa9b4fd6a5Ted Kremenek/// \param FSet1 The first lockset. 2014ad0fe03b897f9486191e75c8d90c3ffa9b4fd6a5Ted Kremenek/// \param FSet2 The second lockset. 20150da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins/// \param JoinLoc The location of the join point for error reporting 2016879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins/// \param LEK1 The error message to report if a mutex is missing from LSet1 2017879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins/// \param LEK2 The error message to report if a mutex is missing from Lset2 2018a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchinsvoid ThreadSafetyAnalyzer::intersectAndWarn(FactSet &FSet1, 2019a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins const FactSet &FSet2, 2020a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins SourceLocation JoinLoc, 2021a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LockErrorKind LEK1, 2022a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LockErrorKind LEK2, 2023a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins bool Modify) { 2024a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet FSet1Orig = FSet1; 2025a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins 2026451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins // Find locks in FSet2 that conflict or are not in FSet1, and warn. 20276bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &Fact : FSet2) { 2028176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry *LDat1 = nullptr; 2029176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry *LDat2 = &FactMan[Fact]; 2030176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FactSet::iterator Iter1 = FSet1.findLockIter(FactMan, *LDat2); 2031176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Iter1 != FSet1.end()) LDat1 = &FactMan[*Iter1]; 2032176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 2033176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LDat1) { 2034176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LDat1->kind() != LDat2->kind()) { 2035176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.handleExclusiveAndShared("mutex", LDat2->toString(), 2036176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat2->loc(), LDat1->loc()); 2037176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Modify && LDat1->kind() != LK_Exclusive) { 2038451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins // Take the exclusive lock, which is the one in FSet2. 2039176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines *Iter1 = Fact; 2040a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins } 2041402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2042176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else if (Modify && LDat1->asserted() && !LDat2->asserted()) { 2043451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins // The non-asserted lock in FSet2 is the one we want to track. 2044176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines *Iter1 = Fact; 20455c6134fd09bc5b738dafdd1c774edde13d95cb20DeLesley Hutchins } 2046402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } else { 2047176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat2->handleRemovalFromIntersection(FSet2, FactMan, JoinLoc, LEK1, 2048176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler); 2049402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2050402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2051402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2052451f8e4ed63c97065fcbc79cf1cbbbbe1c4b6bd9DeLesley Hutchins // Find locks in FSet1 that are not in FSet2, and remove them. 20536bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &Fact : FSet1Orig) { 2054176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry *LDat1 = &FactMan[Fact]; 2055176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FactEntry *LDat2 = FSet2.findLock(FactMan, *LDat1); 2056176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 2057176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!LDat2) { 2058176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LDat1->handleRemovalFromIntersection(FSet1Orig, FactMan, JoinLoc, LEK2, 2059176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler); 2060a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins if (Modify) 2061176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines FSet1.removeLock(FactMan, *LDat1); 2062402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2063402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2064402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 2065402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2066cb96751b25a934b22402c1e4e0805db7608a5f2bCaitlin Sadowski 20670ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins// Return true if block B never continues to its successors. 20683ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarstatic bool neverReturns(const CFGBlock *B) { 20690ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins if (B->hasNoReturnElement()) 20700ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins return true; 20710ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins if (B->empty()) 20720ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins return false; 20730ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins 20740ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins CFGElement Last = B->back(); 2075b07805485c603be3d8011f72611465324c9e664bDavid Blaikie if (Optional<CFGStmt> S = Last.getAs<CFGStmt>()) { 2076b07805485c603be3d8011f72611465324c9e664bDavid Blaikie if (isa<CXXThrowExpr>(S->getStmt())) 20770ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins return true; 20780ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins } 20790ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins return false; 20800ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins} 20810ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins 20825381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 2083402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \brief Check a function's CFG for thread-safety violations. 2084402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// 2085402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// We traverse the blocks in the CFG, compute the set of mutexes that are held 2086402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// at the end of each block, and issue warnings for thread safety violations. 2087402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// Each block in the CFG is traversed exactly once. 20881d26f48dc2eea1c07431ca1519d7034a21b9bcffTed Kremenekvoid ThreadSafetyAnalyzer::runAnalysis(AnalysisDeclContext &AC) { 20896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // TODO: this whole function needs be rewritten as a visitor for CFGWalker. 20906bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // For now, we just use the walker to set things up. 20916bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines threadSafety::CFGWalker walker; 20926bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (!walker.init(AC)) 20936bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return; 20949f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins 20950da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins // AC.dumpCFG(true); 20966bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // threadSafety::printSCFG(walker); 20976bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 20986bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines CFG *CFGraph = walker.getGraph(); 20996bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const NamedDecl *D = walker.getDecl(); 2100176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FunctionDecl *CurrentFunction = dyn_cast<FunctionDecl>(D); 2101176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CurrentMethod = dyn_cast<CXXMethodDecl>(D); 21020da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins 2103651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (D->hasAttr<NoThreadSafetyAnalysisAttr>()) 21049f80a97408ee0da939654d851ff42ad07d47e9c7DeLesley Hutchins return; 21056bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 21062f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // FIXME: Do something a bit more intelligent inside constructor and 21072f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // destructor code. Constructors and destructors must assume unique access 21082f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // to 'this', so checks on member variable access is disabled, but we should 21092f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // still enable checks on other objects. 21102f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins if (isa<CXXConstructorDecl>(D)) 21112f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins return; // Don't check inside constructors. 21122f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins if (isa<CXXDestructorDecl>(D)) 21132f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins return; // Don't check inside destructors. 2114402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2115176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.enterFunction(CurrentFunction); 2116176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 211754c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins BlockInfo.resize(CFGraph->getNumBlockIDs(), 2118a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins CFGBlockInfo::getEmptyBlockInfo(LocalVarMap)); 2119402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2120402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // We need to explore the CFG via a "topological" ordering. 2121402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // That way, we will be guaranteed to have information about required 2122402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // predecessor locksets when exploring a new block. 21236bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines const PostOrderCFGView *SortedGraph = walker.getSortedGraph(); 2124439ed1656664b29841f70b6c0b91460534ff4d93Ted Kremenek PostOrderCFGView::CFGBlockSet VisitedBlocks(CFGraph); 2125402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2126d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins // Mark entry block as reachable 2127d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins BlockInfo[CFGraph->getEntry().getBlockID()].Reachable = true; 2128d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins 2129b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Compute SSA names for local variables 2130b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins LocalVarMap.traverseCFG(CFGraph, SortedGraph, BlockInfo); 2131b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 21322e5156274b8051217565b557bfa14c80f7990e9cRichard Smith // Fill in source locations for all CFGBlocks. 21332e5156274b8051217565b557bfa14c80f7990e9cRichard Smith findBlockLocations(CFGraph, SortedGraph, BlockInfo); 21342e5156274b8051217565b557bfa14c80f7990e9cRichard Smith 2135176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet ExclusiveLocksAcquired; 2136176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet SharedLocksAcquired; 2137176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet LocksReleased; 21385696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins 2139a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins // Add locks from exclusive_locks_required and shared_locks_required 21402f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // to initial lockset. Also turn off checking for lock and unlock functions. 21412f13bec63b0236b169b026b7bc852da51ee029a7DeLesley Hutchins // FIXME: is there a more intelligent way to check lock/unlock functions? 2142439ed1656664b29841f70b6c0b91460534ff4d93Ted Kremenek if (!SortedGraph->empty() && D->hasAttrs()) { 2143439ed1656664b29841f70b6c0b91460534ff4d93Ted Kremenek const CFGBlock *FirstBlock = *SortedGraph->begin(); 2144a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet &InitialLockset = BlockInfo[FirstBlock->getBlockID()].EntrySet; 21455381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 2146176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet ExclusiveLocksToAdd; 2147176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CapExprSet SharedLocksToAdd; 2148651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines StringRef CapDiagKind = "mutex"; 21495381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 21505381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins SourceLocation Loc = D->getLocation(); 21510e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (const auto *Attr : D->attrs()) { 21525381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins Loc = Attr->getLocation(); 21536bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (const auto *A = dyn_cast<RequiresCapabilityAttr>(Attr)) { 2154651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines getMutexIDs(A->isShared() ? SharedLocksToAdd : ExclusiveLocksToAdd, A, 21556bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines nullptr, D); 2156651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 21576bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } else if (const auto *A = dyn_cast<ReleaseCapabilityAttr>(Attr)) { 21585696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // UNLOCK_FUNCTION() is used to hide the underlying lock implementation. 21595696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // We must ignore such methods. 21605696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins if (A->args_size() == 0) 21615696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins return; 21625696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // FIXME -- deal with exclusive vs. shared unlock functions? 21636bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines getMutexIDs(ExclusiveLocksToAdd, A, nullptr, D); 21646bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines getMutexIDs(LocksReleased, A, nullptr, D); 2165651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 21666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } else if (const auto *A = dyn_cast<AcquireCapabilityAttr>(Attr)) { 21675696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins if (A->args_size() == 0) 21685696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins return; 2169651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines getMutexIDs(A->isShared() ? SharedLocksAcquired 2170651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines : ExclusiveLocksAcquired, 2171651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines A, nullptr, D); 2172651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines CapDiagKind = ClassifyDiagnostic(A); 217376f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins } else if (isa<ExclusiveTrylockFunctionAttr>(Attr)) { 217476f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins // Don't try to check trylock functions for now 217576f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins return; 217676f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins } else if (isa<SharedTrylockFunctionAttr>(Attr)) { 217776f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins // Don't try to check trylock functions for now 217876f0a6e9bc9ee5aae029f959f64fae290727cca4DeLesley Hutchins return; 2179cb96751b25a934b22402c1e4e0805db7608a5f2bCaitlin Sadowski } 2180cb96751b25a934b22402c1e4e0805db7608a5f2bCaitlin Sadowski } 21815381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins 21825381c05f51e5b7c7627f1d95b9a3425303ce086aDeLesley Hutchins // FIXME -- Loc can be wrong here. 21830e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (const auto &Mu : ExclusiveLocksToAdd) { 21840e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto Entry = llvm::make_unique<LockableFactEntry>(Mu, LK_Exclusive, Loc); 21850e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Entry->setDeclared(true); 21860e2c34f92f00628d48968dfea096d36381f494cbStephen Hines addLock(InitialLockset, std::move(Entry), CapDiagKind, true); 21870e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 21880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines for (const auto &Mu : SharedLocksToAdd) { 21890e2c34f92f00628d48968dfea096d36381f494cbStephen Hines auto Entry = llvm::make_unique<LockableFactEntry>(Mu, LK_Shared, Loc); 21900e2c34f92f00628d48968dfea096d36381f494cbStephen Hines Entry->setDeclared(true); 21910e2c34f92f00628d48968dfea096d36381f494cbStephen Hines addLock(InitialLockset, std::move(Entry), CapDiagKind, true); 21920e2c34f92f00628d48968dfea096d36381f494cbStephen Hines } 2193cb96751b25a934b22402c1e4e0805db7608a5f2bCaitlin Sadowski } 2194cb96751b25a934b22402c1e4e0805db7608a5f2bCaitlin Sadowski 21956bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *CurrBlock : *SortedGraph) { 2196402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski int CurrBlockID = CurrBlock->getBlockID(); 2197b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins CFGBlockInfo *CurrBlockInfo = &BlockInfo[CurrBlockID]; 2198402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2199402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // Use the default initial lockset in case there are no predecessors. 2200b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins VisitedBlocks.insert(CurrBlock); 2201402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2202402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // Iterate through the predecessor blocks and warn if the lockset for all 2203402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // predecessors is not the same. We take the entry lockset of the current 2204402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // block to be the intersection of all previous locksets. 2205402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // FIXME: By keeping the intersection, we may output more errors in future 2206402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // for a lock which is not in the intersection, but was in the union. We 2207402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // may want to also keep the union in future. As an example, let's say 2208402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // the intersection contains Mutex L, and the union contains L and M. 2209402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // Later we unlock M. At this point, we would output an error because we 2210402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // never locked M; although the real error is probably that we forgot to 2211402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // lock M on all code paths. Conversely, let's say that later we lock M. 2212402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // In this case, we should compare against the intersection instead of the 2213402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // union because the real error is probably that we forgot to unlock M on 2214402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // all code paths. 2215402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski bool LocksetInitialized = false; 2216cfa88f893915ceb8ae4ce2f17c46c24a4d67502fDmitri Gribenko SmallVector<CFGBlock *, 8> SpecialBlocks; 2217402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski for (CFGBlock::const_pred_iterator PI = CurrBlock->pred_begin(), 2218402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski PE = CurrBlock->pred_end(); PI != PE; ++PI) { 2219402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2220402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // if *PI -> CurrBlock is a back edge 22216bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (*PI == nullptr || !VisitedBlocks.alreadySet(*PI)) 2222402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski continue; 2223402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2224d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins int PrevBlockID = (*PI)->getBlockID(); 2225d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins CFGBlockInfo *PrevBlockInfo = &BlockInfo[PrevBlockID]; 2226d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins 22272a35be803c405221f5f23c7bdedb91f09efdd3acDeLesley Hutchins // Ignore edges from blocks that can't return. 22280ecc2e9ce86b0705bc1a53a9c8f90c433bcdca1bDeLesley Hutchins if (neverReturns(*PI) || !PrevBlockInfo->Reachable) 22292a35be803c405221f5f23c7bdedb91f09efdd3acDeLesley Hutchins continue; 22302a35be803c405221f5f23c7bdedb91f09efdd3acDeLesley Hutchins 2231d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins // Okay, we can reach this block from the entry. 2232d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins CurrBlockInfo->Reachable = true; 2233d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins 2234aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // If the previous block ended in a 'continue' or 'break' statement, then 2235aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // a difference in locksets is probably due to a bug in that block, rather 2236aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // than in some other predecessor. In that case, keep the other 2237aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // predecessor's lockset. 2238aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith if (const Stmt *Terminator = (*PI)->getTerminator()) { 2239aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith if (isa<ContinueStmt>(Terminator) || isa<BreakStmt>(Terminator)) { 2240aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith SpecialBlocks.push_back(*PI); 2241aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith continue; 2242aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith } 2243aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith } 2244aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith 2245a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet PrevLockset; 2246a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins getEdgeLockset(PrevLockset, PrevBlockInfo->ExitSet, *PI, CurrBlock); 2247b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins 2248402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski if (!LocksetInitialized) { 22490da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins CurrBlockInfo->EntrySet = PrevLockset; 2250402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski LocksetInitialized = true; 2251402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } else { 2252a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins intersectAndWarn(CurrBlockInfo->EntrySet, PrevLockset, 2253a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins CurrBlockInfo->EntryLoc, 2254a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LEK_LockedSomePredecessors); 2255402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2256402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2257402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2258d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins // Skip rest of block if it's not reachable. 2259d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins if (!CurrBlockInfo->Reachable) 2260d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins continue; 2261d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins 2262aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // Process continue and break blocks. Assume that the lockset for the 2263aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // resulting block is unaffected by any discrepancies in them. 22646bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto *PrevBlock : SpecialBlocks) { 2265aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith int PrevBlockID = PrevBlock->getBlockID(); 2266aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith CFGBlockInfo *PrevBlockInfo = &BlockInfo[PrevBlockID]; 2267aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith 2268aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith if (!LocksetInitialized) { 2269aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith CurrBlockInfo->EntrySet = PrevBlockInfo->ExitSet; 2270aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith LocksetInitialized = true; 2271aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith } else { 2272aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // Determine whether this edge is a loop terminator for diagnostic 2273aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // purposes. FIXME: A 'break' statement might be a loop terminator, but 2274aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // it might also be part of a switch. Also, a subsequent destructor 2275aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // might add to the lockset, in which case the real issue might be a 2276aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // double lock on the other path. 2277aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith const Stmt *Terminator = PrevBlock->getTerminator(); 2278aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith bool IsLoop = Terminator && isa<ContinueStmt>(Terminator); 2279aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith 2280a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins FactSet PrevLockset; 2281a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins getEdgeLockset(PrevLockset, PrevBlockInfo->ExitSet, 2282a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins PrevBlock, CurrBlock); 22830da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins 2284aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith // Do not update EntrySet. 22850da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins intersectAndWarn(CurrBlockInfo->EntrySet, PrevLockset, 22860da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins PrevBlockInfo->ExitLoc, 2287aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith IsLoop ? LEK_LockedSomeLoopIterations 2288a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins : LEK_LockedSomePredecessors, 2289a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins false); 2290aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith } 2291aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith } 2292aacde7174af6c5759b52dc0ceb7b167d323afb6aRichard Smith 229354c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins BuildLockset LocksetBuilder(this, *CurrBlockInfo); 229454c350a67b47f059e1d577bdd9e2d1dc31ff82b5DeLesley Hutchins 2295b37d2b5c0819d9ef596c7baec1e0be0d7c45b547DeLesley Hutchins // Visit all the statements in the basic block. 2296402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski for (CFGBlock::const_iterator BI = CurrBlock->begin(), 2297402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski BE = CurrBlock->end(); BI != BE; ++BI) { 22986db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins switch (BI->getKind()) { 22996db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins case CFGElement::Statement: { 2300fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie CFGStmt CS = BI->castAs<CFGStmt>(); 2301fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie LocksetBuilder.Visit(const_cast<Stmt*>(CS.getStmt())); 23026db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins break; 23036db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins } 23046db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins // Ignore BaseDtor, MemberDtor, and TemporaryDtor for now. 23056db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins case CFGElement::AutomaticObjectDtor: { 2306fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie CFGAutomaticObjDtor AD = BI->castAs<CFGAutomaticObjDtor>(); 2307fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie CXXDestructorDecl *DD = const_cast<CXXDestructorDecl *>( 2308fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie AD.getDestructorDecl(AC.getASTContext())); 23096db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins if (!DD->hasAttrs()) 23106db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins break; 23116db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins 23126db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins // Create a dummy expression, 2313fdf6a279c9a75c778eba382d9a156697092982a1David Blaikie VarDecl *VD = const_cast<VarDecl*>(AD.getVarDecl()); 23143ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar DeclRefExpr DRE(VD, false, VD->getType().getNonReferenceType(), 23153ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar VK_LValue, AD.getTriggerStmt()->getLocEnd()); 23166db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins LocksetBuilder.handleCall(&DRE, DD); 23176db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins break; 23186db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins } 23196db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins default: 23206db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins break; 23216db51f707e93816364039a2a904d13d3968c7f05DeLesley Hutchins } 2322402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2323a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins CurrBlockInfo->ExitSet = LocksetBuilder.FSet; 2324402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2325402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // For every back edge from CurrBlock (the end of the loop) to another block 2326402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // (FirstLoopBlock) we need to check that the Lockset of Block is equal to 2327402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // the one held at the beginning of FirstLoopBlock. We can look up the 2328402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // Lockset held at the beginning of FirstLoopBlock in the EntryLockSets map. 2329402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(), 2330402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski SE = CurrBlock->succ_end(); SI != SE; ++SI) { 2331402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2332402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski // if CurrBlock -> *SI is *not* a back edge 23336bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (*SI == nullptr || !VisitedBlocks.alreadySet(*SI)) 2334402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski continue; 2335402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2336402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski CFGBlock *FirstLoopBlock = *SI; 23370da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins CFGBlockInfo *PreLoop = &BlockInfo[FirstLoopBlock->getBlockID()]; 23380da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins CFGBlockInfo *LoopEnd = &BlockInfo[CurrBlockID]; 23390da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins intersectAndWarn(LoopEnd->ExitSet, PreLoop->EntrySet, 23400da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins PreLoop->EntryLoc, 2341a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LEK_LockedSomeLoopIterations, 2342a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins false); 2343402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2344402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2345402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 2346d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins CFGBlockInfo *Initial = &BlockInfo[CFGraph->getEntry().getBlockID()]; 2347d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins CFGBlockInfo *Final = &BlockInfo[CFGraph->getExit().getBlockID()]; 23482a237e03c407ff55bd8639b18658a8751955f1dbDeLesley Hutchins 23492a237e03c407ff55bd8639b18658a8751955f1dbDeLesley Hutchins // Skip the final check if the exit block is unreachable. 2350d2f388299153d80cbe5ffaaed8a882b59a1b59bcDeLesley Hutchins if (!Final->Reachable) 23512a237e03c407ff55bd8639b18658a8751955f1dbDeLesley Hutchins return; 23522a237e03c407ff55bd8639b18658a8751955f1dbDeLesley Hutchins 23535696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // By default, we expect all locks held on entry to be held on exit. 23545696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins FactSet ExpectedExitSet = Initial->EntrySet; 23555696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins 23565696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // Adjust the expected exit set by adding or removing locks, as declared 23575696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // by *-LOCK_FUNCTION and UNLOCK_FUNCTION. The intersect below will then 23585696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // issue the appropriate warning. 23595696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins // FIXME: the location here is not quite right. 23606bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &Lock : ExclusiveLocksAcquired) 2361176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ExpectedExitSet.addLock(FactMan, llvm::make_unique<LockableFactEntry>( 2362176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Lock, LK_Exclusive, D->getLocation())); 23636bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &Lock : SharedLocksAcquired) 2364176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ExpectedExitSet.addLock(FactMan, llvm::make_unique<LockableFactEntry>( 2365176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Lock, LK_Shared, D->getLocation())); 23666bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines for (const auto &Lock : LocksReleased) 23676bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines ExpectedExitSet.removeLock(FactMan, Lock); 23685696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins 23691748b1256646cf0752f172c53ad7482f7beed185Caitlin Sadowski // FIXME: Should we call this function for all blocks which exit the function? 23705696884053b4a60dbed01ea8c7e6cd8dcf9b5de9DeLesley Hutchins intersectAndWarn(ExpectedExitSet, Final->ExitSet, 23710da4414f3d30c34fafb81b13b2cec3680c0bc9e1DeLesley Hutchins Final->ExitLoc, 2372879a4334e4c4cab0c22ba91492ffc2838bbc21fcDeLesley Hutchins LEK_LockedAtEndOfFunction, 2373a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins LEK_NotLockedAtEndOfFunction, 2374a1fa47139d6e9e7dcc40f2809605d1a258624e7fDeLesley Hutchins false); 2375a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 2376176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handler.leaveFunction(CurrentFunction); 2377176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines} 2378a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 2379a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins 2380a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins/// \brief Check a function's CFG for thread-safety violations. 2381a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins/// 2382a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins/// We traverse the blocks in the CFG, compute the set of mutexes that are held 2383a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins/// at the end of each block, and issue warnings for thread safety violations. 2384a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins/// Each block in the CFG is traversed exactly once. 23853ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarvoid threadSafety::runThreadSafetyAnalysis(AnalysisDeclContext &AC, 23863ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar ThreadSafetyHandler &Handler, 23873ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar BeforeSet **BSet) { 23880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (!*BSet) 23890e2c34f92f00628d48968dfea096d36381f494cbStephen Hines *BSet = new BeforeSet; 23900e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ThreadSafetyAnalyzer Analyzer(Handler, *BSet); 2391a60448d6dfc91f4c30987e237bf70ef50ac7705bDeLesley Hutchins Analyzer.runAnalysis(AC); 2392402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 2393402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski 23943ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainarvoid threadSafety::threadSafetyCleanup(BeforeSet *Cache) { delete Cache; } 23950e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 2396402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// \brief Helper function that returns a LockKind required for the given level 2397402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski/// of access. 23983ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga NainarLockKind threadSafety::getLockKindFromAccessKind(AccessKind AK) { 2399402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski switch (AK) { 2400402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski case AK_Read : 2401402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski return LK_Shared; 2402402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski case AK_Written : 2403402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski return LK_Exclusive; 2404402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski } 2405afc5b15022886c9e9e84d7aa0f2168b83e712310Benjamin Kramer llvm_unreachable("Unknown AccessKind"); 2406402aa0698fec81e574818a0a6c2000fac0b2c4c6Caitlin Sadowski} 2407