[cfe-commits] r139722 - in /cfe/trunk: include/clang/Analysis/Analyses/ThreadSafety.h lib/Analysis/ThreadSafety.cpp
Chandler Carruth
chandlerc at google.com
Wed Sep 14 13:15:20 PDT 2011
On Wed, Sep 14, 2011 at 1:05 PM, Caitlin Sadowski <supertri at google.com>wrote:
> Author: supertri
> Date: Wed Sep 14 15:05:09 2011
> New Revision: 139722
>
> URL: http://llvm.org/viewvc/llvm-project?rev=139722&view=rev
> Log:
> Thread safety: adding additional documentation to the main thread safety
> interface, and making the destructor for the thread safety handler pure
> virtual
>
> Modified:
> cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h
> cfe/trunk/lib/Analysis/ThreadSafety.cpp
>
> Modified: cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h?rev=139722&r1=139721&r2=139722&view=diff
>
> ==============================================================================
> --- cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h (original)
> +++ cfe/trunk/include/clang/Analysis/Analyses/ThreadSafety.h Wed Sep 14
> 15:05:09 2011
> @@ -11,7 +11,8 @@
> // A intra-procedural analysis for thread safety (e.g. deadlocks and race
> // conditions), based off of an annotation system.
> //
> -// See http://gcc.gnu.org/wiki/ThreadSafetyAnnotation for the gcc
> version.
> +// See http://clang.llvm.org/docs/LanguageExtensions.html#threadsafetyfor more
> +// information.
> //
>
> //===----------------------------------------------------------------------===//
>
> @@ -25,46 +26,130 @@
> namespace clang {
> namespace thread_safety {
>
> +/// This enum distinguishes between different kinds of operations that may
> +/// need to be protected by locks. We use this enum in error handling.
> +/// \enum POK_VarDereference -- Dereferencing a variable (e.g. p in *p =
> 5;)
>
Rather than using \enum here, I suspect you can just put the content after
the '--' in a doxygen comment before the enumerator, or even on the same
line.
> +/// \enum POK_VarAccess -- Reading or writing a variable (e.g. x in x =
> 5;)
> +/// \enum POK_FunctionCall -- making a function call (e.g. fool())
> enum ProtectedOperationKind {
POK_VarDereference,
> POK_VarAccess,
> POK_FunctionCall
> };
>
> +/// This enum distinguishes between different kinds of lock actions. For
> +/// example, it is an error to write a variable protected by shared
> version of a
> +/// mutex.
> +/// \enum LK_Shared -- Shared/reader lock of a mutex
> +/// \enum LK_Exclusive -- Exclusive/writer lock of a mutex
> enum LockKind {
> LK_Shared,
> LK_Exclusive
> };
>
> +/// This enum distinguishes between different ways to access (read or
> write) a
> +/// variable.
> +/// \enum AK_Read -- reading a variable
> +/// \enum AK_Written -- writing a variable
> enum AccessKind {
> AK_Read,
> AK_Written
> };
>
> +/// Handler class for thread safety warnings.
> class ThreadSafetyHandler {
> public:
> typedef llvm::StringRef Name;
> - ThreadSafetyHandler() {}
> - virtual ~ThreadSafetyHandler() {}
> + virtual ~ThreadSafetyHandler() = 0;
>
+
> + /// Warn about lock expressions which fail to resolve to lockable
> objects.
> + /// \param Loc -- the SourceLocation of the unresolved expression.
> virtual void handleInvalidLockExp(SourceLocation Loc) {}
> +
> + /// Warn about unlock function calls that do not have a prior matching
> lock
> + /// expression.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc -- The SourceLocation of the Unlock
> virtual void handleUnmatchedUnlock(Name LockName, SourceLocation Loc) {}
> +
> + /// Warn about lock function calls for locks which are already held.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc -- The Loc of the second lock expression.
>
Here and below I would expand the abbreviation in your prose when you're not
referring to the specific named object. Essentially:
s/The Loc/The location/
> virtual void handleDoubleLock(Name LockName, SourceLocation Loc) {}
> +
> + /// Warn about situations where a mutex is sometimes held and sometimes
> not.
> + /// For example, a mutex is locked on an "if" branch but not the "else"
> + /// branch.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc -- The Loc of the lock expression where the mutex is
> locked
> virtual void handleMutexHeldEndOfScope(Name LockName, SourceLocation
> Loc){}
> +
> + /// Warn when a mutex is only held at the start of some loop iterations.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc -- The Loc of the lock expression.
> virtual void handleNoLockLoopEntry(Name LockName, SourceLocation Loc) {}
> +
> + /// Warn when a mutex is locked but not unlocked inside a function.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param FunName -- The name of the function
> + /// \param Loc -- The Loc of the lock expression
> virtual void handleNoUnlock(Name LockName, Name FunName,
> SourceLocation Loc) {}
> +
> + /// Warn when a mutex is held exclusively and shared at the same point.
> For
> + /// example, if a mutex is locked exclusively during an if branch and
> shared
> + /// during the else branch.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc1 -- The Loc of the first lock expression.
> + /// \param Loc2 -- The Loc of the second lock expression.
> virtual void handleExclusiveAndShared(Name LockName, SourceLocation Loc1,
> SourceLocation Loc2) {}
> +
> + /// Warn when a protected operation occurs while no locks are held.
> + /// \param D -- The decl for the protected variable or function
> + /// \param POK -- The kind of protected operation (e.g. variable access)
> + /// \param AK -- The kind of access (i.e. read or write) that occurred
> + /// \param Loc -- The Loc of the protected operation.
> virtual void handleNoMutexHeld(const NamedDecl *D, ProtectedOperationKind
> POK,
> AccessKind AK, SourceLocation Loc) {}
> +
> + /// Warn when a protected operation occurs while the specific mutex
> protecting
> + /// the operation is not locked.
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param D -- The decl for the protected variable or function
> + /// \param POK -- The kind of protected operation (e.g. variable access)
> + /// \param AK -- The kind of access (i.e. read or write) that occurred
> + /// \param Loc -- The Loc of the protected operation.
> virtual void handleMutexNotHeld(const NamedDecl *D,
> ProtectedOperationKind POK, Name
> LockName,
> LockKind LK, SourceLocation Loc) {}
> +
> + /// Warn when a function is called while an excluded mutex is locked.
> For
> + /// example, the mutex may be locked inside the function.
> + /// \param FunName -- The name of the function
> + /// \param LockName -- A StringRef name for the lock expression, to be
> printed
> + /// in the error message.
> + /// \param Loc -- The Loc of the function call.
> virtual void handleFunExcludesLock(Name FunName, Name LockName,
> SourceLocation Loc) {}
> };
>
> +/// \brief Check a function's CFG for thread-safety violations.
> +///
> +/// We traverse the blocks in the CFG, compute the set of mutexes that are
> held
> +/// at the end of each block, and issue warnings for thread safety
> violations.
> +/// Each block in the CFG is traversed exactly once.
> void runThreadSafetyAnalysis(AnalysisContext &AC, ThreadSafetyHandler
> &Handler);
> +
> +/// \brief Helper function that returns a LockKind required for the given
> level
> +/// of access.
> LockKind getLockKindFromAccessKind(AccessKind AK);
>
> }} // end namespace clang::thread_safety
>
> Modified: cfe/trunk/lib/Analysis/ThreadSafety.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/ThreadSafety.cpp?rev=139722&r1=139721&r2=139722&view=diff
>
> ==============================================================================
> --- cfe/trunk/lib/Analysis/ThreadSafety.cpp (original)
> +++ cfe/trunk/lib/Analysis/ThreadSafety.cpp Wed Sep 14 15:05:09 2011
> @@ -10,7 +10,8 @@
> // A intra-procedural analysis for thread safety (e.g. deadlocks and race
> // conditions), based off of an annotation system.
> //
> -// See http://gcc.gnu.org/wiki/ThreadSafetyAnnotation for the gcc
> version.
> +// See http://clang.llvm.org/docs/LanguageExtensions.html#threadsafetyfor more
> +// information.
> //
>
> //===----------------------------------------------------------------------===//
>
> @@ -36,6 +37,9 @@
> using namespace clang;
> using namespace thread_safety;
>
> +// Key method definition
> +ThreadSafetyHandler::~ThreadSafetyHandler() {}
> +
> // Helper functions
> static Expr *getParent(Expr *Exp) {
> if (MemberExpr *ME = dyn_cast<MemberExpr>(Exp))
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20110914/18db9ed6/attachment.html>
More information about the cfe-commits
mailing list