r188206 - Patch by Chris Wailes <chris.wailes at gmail.com>.
Aaron Ballman
aaron at aaronballman.com
Mon Aug 12 16:39:04 PDT 2013
On Mon, Aug 12, 2013 at 5:20 PM, DeLesley Hutchins <delesley at google.com> wrote:
> Author: delesley
> Date: Mon Aug 12 16:20:55 2013
> New Revision: 188206
>
> URL: http://llvm.org/viewvc/llvm-project?rev=188206&view=rev
> Log:
> Patch by Chris Wailes <chris.wailes at gmail.com>.
> Reviewed by delesley, dblaikie.
>
> Add the annotations and code needed to support a basic 'consumed' analysis.
>
> Summary:
> This new analysis is based on academic literature on linear types. It tracks
> the state of a value, either as unconsumed, consumed, or unknown. Methods are
> then annotated as CallableWhenUnconsumed, and when an annotated method is
> called while the value is in the 'consumed' state a warning is issued. A value
> may be tested in the conditional statement of an if-statement; when this occurs
> we know the state of the value in the different branches, and this information
> is added to our analysis. The code is still highly experimental, and the names
> of annotations or the algorithm may be subject to change.
>
> Added:
> cfe/trunk/include/clang/Analysis/Analyses/Consumed.h
> cfe/trunk/include/clang/Sema/ConsumedWarningsHandler.h
> cfe/trunk/lib/Analysis/Consumed.cpp
> cfe/trunk/test/SemaCXX/warn-consumed-analysis-strict.cpp
> cfe/trunk/test/SemaCXX/warn-consumed-analysis.cpp
> cfe/trunk/test/SemaCXX/warn-consumed-parsing.cpp
> Modified:
> cfe/trunk/include/clang/Basic/Attr.td
> cfe/trunk/include/clang/Basic/DiagnosticGroups.td
> cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
> cfe/trunk/include/clang/Sema/AnalysisBasedWarnings.h
> cfe/trunk/lib/Analysis/CMakeLists.txt
> cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp
> cfe/trunk/lib/Sema/SemaDeclAttr.cpp
>
> Added: cfe/trunk/include/clang/Analysis/Analyses/Consumed.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Analysis/Analyses/Consumed.h?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/include/clang/Analysis/Analyses/Consumed.h (added)
> +++ cfe/trunk/include/clang/Analysis/Analyses/Consumed.h Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,140 @@
> +//===- Consumed.h ----------------------------------------------*- C++ --*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// A intra-procedural analysis for checking consumed properties. This is based,
> +// in part, on research on linear types.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_CLANG_CONSUMED_H
> +#define LLVM_CLANG_CONSUMED_H
> +
> +#include "clang/AST/DeclCXX.h"
> +#include "clang/AST/ExprCXX.h"
> +#include "clang/AST/StmtCXX.h"
> +#include "clang/Analysis/AnalysisContext.h"
> +#include "clang/Analysis/Analyses/PostOrderCFGView.h"
> +#include "clang/Basic/SourceLocation.h"
> +#include "clang/Sema/ConsumedWarningsHandler.h"
> +#include "clang/Sema/Sema.h"
> +
> +namespace clang {
> +namespace consumed {
> +
> + enum ConsumedState {
> + // No state information for the given variable.
> + CS_None,
> +
> + CS_Unknown,
> + CS_Unconsumed,
> + CS_Consumed
> + };
> +
> + class ConsumedStateMap {
> +
> + typedef llvm::DenseMap<const VarDecl *, ConsumedState> MapType;
> + typedef std::pair<const VarDecl *, ConsumedState> PairType;
> +
> + protected:
> +
> + MapType Map;
> +
> + public:
> + /// \brief Get the consumed state of a given variable.
> + ConsumedState getState(const VarDecl *Var);
> +
> + /// \brief Merge this state map with another map.
> + void intersect(const ConsumedStateMap *Other);
> +
> + /// \brief Mark all variables as unknown.
> + void makeUnknown();
> +
> + /// \brief Set the consumed state of a given variable.
> + void setState(const VarDecl *Var, ConsumedState State);
> + };
> +
> + class ConsumedBlockInfo {
> +
> + ConsumedStateMap **StateMapsArray;
> + PostOrderCFGView::CFGBlockSet VisitedBlocks;
> +
> + public:
> +
> + ConsumedBlockInfo() : StateMapsArray(NULL) {}
> +
> + ConsumedBlockInfo(const CFG *CFGraph)
> + : StateMapsArray(new ConsumedStateMap*[CFGraph->getNumBlockIDs()]()),
> + VisitedBlocks(CFGraph) {}
> +
> + void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap,
> + bool &AlreadyOwned);
> + void addInfo(const CFGBlock *Block, ConsumedStateMap *StateMap);
> +
> + ConsumedStateMap* getInfo(const CFGBlock *Block);
> +
> + void markVisited(const CFGBlock *Block);
> + };
> +
> + struct VarTestResult {
> + const VarDecl *Var;
> + SourceLocation Loc;
> + bool UnconsumedInTrueBranch;
> +
> + VarTestResult() : Var(NULL), Loc(), UnconsumedInTrueBranch(true) {}
> +
> + VarTestResult(const VarDecl *Var, SourceLocation Loc,
> + bool UnconsumedInTrueBranch)
> + : Var(Var), Loc(Loc), UnconsumedInTrueBranch(UnconsumedInTrueBranch) {}
> + };
> +
> + /// A class that handles the analysis of uniqueness violations.
> + class ConsumedAnalyzer {
> +
> + typedef llvm::DenseMap<const CXXRecordDecl *, bool> CacheMapType;
> + typedef std::pair<const CXXRecordDecl *, bool> CachePairType;
> +
> + Sema &S;
> +
> + ConsumedBlockInfo BlockInfo;
> + ConsumedStateMap *CurrStates;
> +
> + CacheMapType ConsumableTypeCache;
> +
> + bool hasConsumableAttributes(const CXXRecordDecl *RD);
> + void splitState(const CFGBlock *CurrBlock, const IfStmt *Terminator);
> +
> + public:
> +
> + ConsumedWarningsHandlerBase &WarningsHandler;
> +
> + ConsumedAnalyzer(Sema &S, ConsumedWarningsHandlerBase &WarningsHandler)
> + : S(S), WarningsHandler(WarningsHandler) {}
> +
> + /// \brief Get a constant reference to the Sema object.
> + const Sema & getSema(void);
> +
> + /// \brief Check to see if the type is a consumable type.
> + bool isConsumableType(QualType Type);
> +
> + /// \brief Check a function's CFG for consumed violations.
> + ///
> + /// We traverse the blocks in the CFG, keeping track of the state of each
> + /// value who's type has uniquness annotations. If methods are invoked in
> + /// the wrong state a warning is issued. Each block in the CFG is traversed
> + /// exactly once.
> + void run(AnalysisDeclContext &AC);
> + };
> +
> + unsigned checkEnabled(DiagnosticsEngine &D);
> + /// \brief Check to see if a function tests an object's validity.
> + bool isTestingFunction(const CXXMethodDecl *MethodDecl);
> +
> +}} // end namespace clang::consumed
> +
> +#endif
>
> Modified: cfe/trunk/include/clang/Basic/Attr.td
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Attr.td?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Basic/Attr.td (original)
> +++ cfe/trunk/include/clang/Basic/Attr.td Mon Aug 12 16:20:55 2013
> @@ -918,6 +918,28 @@ def SharedLocksRequired : InheritableAtt
> let TemplateDependent = 1;
> }
>
> +// C/C++ consumed attributes.
> +
> +def CallableWhenUnconsumed : InheritableAttr {
> + let Spellings = [GNU<"callable_when_unconsumed">];
> + let Subjects = [CXXMethod];
> +}
> +
> +def TestsUnconsumed : InheritableAttr {
> + let Spellings = [GNU<"tests_unconsumed">];
> + let Subjects = [CXXMethod];
> +}
> +
> +def Consumes : InheritableAttr {
> + let Spellings = [GNU<"consumes">];
> + let Subjects = [CXXMethod];
> +}
> +
> +def TestsConsumed : InheritableAttr {
> + let Spellings = [GNU<"tests_consumed">];
> + let Subjects = [CXXMethod];
> +}
> +
> // Type safety attributes for `void *' pointers and type tags.
>
> def ArgumentWithTypeTag : InheritableAttr {
>
> Modified: cfe/trunk/include/clang/Basic/DiagnosticGroups.td
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticGroups.td?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Basic/DiagnosticGroups.td (original)
> +++ cfe/trunk/include/clang/Basic/DiagnosticGroups.td Mon Aug 12 16:20:55 2013
> @@ -478,6 +478,10 @@ def ThreadSafety : DiagGroup<"thread-saf
> ThreadSafetyPrecise]>;
> def ThreadSafetyBeta : DiagGroup<"thread-safety-beta">;
>
> +// Uniqueness Analysis warnings
> +def Consumed : DiagGroup<"consumed">;
> +def ConsumedStrict : DiagGroup<"consumed-strict", [Consumed]>;
> +
> // Note that putting warnings in -Wall will not disable them by default. If a
> // warning should be active _only_ when -Wall is passed in, mark it as
> // DefaultIgnore in addition to putting it here.
>
> Modified: cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td (original)
> +++ cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td Mon Aug 12 16:20:55 2013
> @@ -2178,6 +2178,28 @@ def note_found_mutex_near_match : Note<"
> def warn_thread_safety_beta : Warning<
> "Thread safety beta warning.">, InGroup<ThreadSafetyBeta>, DefaultIgnore;
>
> +// Consumed warnings
> +def warn_use_while_consumed : Warning<
> + "invocation of method '%0' on object '%1' while it is in the 'consumed' "
> + "state">, InGroup<Consumed>, DefaultIgnore;
> +def warn_use_of_temp_while_consumed : Warning<
> + "invocation of method '%0' on a temporary object while it is in the "
> + "'consumed' state">, InGroup<Consumed>, DefaultIgnore;
> +def warn_uniqueness_attribute_wrong_decl_type : Warning<
> + "%0 attribute only applies to methods">,
> + InGroup<Consumed>, DefaultIgnore;
Please use warn_attribute_wrong_decl_type instead.
> +
> +// ConsumedStrict warnings
> +def warn_use_in_unknown_state : Warning<
> + "invocation of method '%0' on object '%1' while it is in an unknown state">,
> + InGroup<ConsumedStrict>, DefaultIgnore;
> +def warn_use_of_temp_in_unknown_state : Warning<
> + "invocation of method '%0' on a temporary object while it is in an unknown "
> + "state">, InGroup<ConsumedStrict>, DefaultIgnore;
> +def warn_unnecessary_test : Warning<
> + "unnecessary test. Variable '%0' is known to be in the '%1' state">,
> + InGroup<ConsumedStrict>, DefaultIgnore;
> +
> def warn_impcast_vector_scalar : Warning<
> "implicit conversion turns vector to scalar: %0 to %1">,
> InGroup<Conversion>, DefaultIgnore;
>
> Modified: cfe/trunk/include/clang/Sema/AnalysisBasedWarnings.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/AnalysisBasedWarnings.h?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/Sema/AnalysisBasedWarnings.h (original)
> +++ cfe/trunk/include/clang/Sema/AnalysisBasedWarnings.h Mon Aug 12 16:20:55 2013
> @@ -38,6 +38,7 @@ public:
> unsigned enableCheckFallThrough : 1;
> unsigned enableCheckUnreachable : 1;
> unsigned enableThreadSafetyAnalysis : 1;
> + unsigned enableConsumedAnalysis : 1;
> public:
> Policy();
> void disableCheckFallThrough() { enableCheckFallThrough = 0; }
>
> Added: cfe/trunk/include/clang/Sema/ConsumedWarningsHandler.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/ConsumedWarningsHandler.h?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/include/clang/Sema/ConsumedWarningsHandler.h (added)
> +++ cfe/trunk/include/clang/Sema/ConsumedWarningsHandler.h Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,98 @@
> +//===- ConsumedWarningsHandler.h -------------------------------*- C++ --*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// A handler class for warnings issued by the consumed analysis.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_CLANG_CONSUMED_WARNING_HANDLER_H
> +#define LLVM_CLANG_CONSUMED_WARNING_HANDLER_H
> +
> +#include <list>
> +#include <utility>
> +
> +#include "clang/Basic/SourceLocation.h"
> +#include "clang/Sema/Sema.h"
> +#include "llvm/ADT/SmallVector.h"
> +#include "llvm/ADT/StringRef.h"
> +
> +namespace clang {
> +namespace consumed {
> +
> + typedef SmallVector<PartialDiagnosticAt, 1> OptionalNotes;
> + typedef std::pair<PartialDiagnosticAt, OptionalNotes> DelayedDiag;
> + typedef std::list<DelayedDiag> DiagList;
> +
> + class ConsumedWarningsHandlerBase {
> +
> + public:
> +
> + virtual ~ConsumedWarningsHandlerBase();
> +
> + /// \brief Emit the warnings and notes left by the analysis.
> + virtual void emitDiagnostics() {}
> +
> + /// Warn about unnecessary-test errors.
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the unnecessary test.
> + virtual void warnUnnecessaryTest(StringRef VariableName,
> + StringRef VariableState,
> + SourceLocation Loc) {}
> +
> + /// Warn about use-while-consumed errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + virtual void warnUseOfTempWhileConsumed(StringRef MethodName,
> + SourceLocation Loc) {}
> +
> + /// Warn about use-in-unknown-state errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + virtual void warnUseOfTempInUnknownState(StringRef MethodName,
> + SourceLocation Loc) {}
> +
> + /// Warn about use-while-consumed errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + virtual void warnUseWhileConsumed(StringRef MethodName,
> + StringRef VariableName,
> + SourceLocation Loc) {}
> +
> + /// Warn about use-in-unknown-state errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + virtual void warnUseInUnknownState(StringRef MethodName,
> + StringRef VariableName,
> + SourceLocation Loc) {}
> + };
> +}} // end clang::consumed
> +
> +#endif
>
> Modified: cfe/trunk/lib/Analysis/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/CMakeLists.txt?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Analysis/CMakeLists.txt (original)
> +++ cfe/trunk/lib/Analysis/CMakeLists.txt Mon Aug 12 16:20:55 2013
> @@ -6,6 +6,7 @@ add_clang_library(clangAnalysis
> CFGStmtMap.cpp
> CallGraph.cpp
> CocoaConventions.cpp
> + Consumed.cpp
> Dominators.cpp
> FormatString.cpp
> LiveVariables.cpp
>
> Added: cfe/trunk/lib/Analysis/Consumed.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Analysis/Consumed.cpp?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/lib/Analysis/Consumed.cpp (added)
> +++ cfe/trunk/lib/Analysis/Consumed.cpp Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,802 @@
> +//===- Consumed.cpp --------------------------------------------*- C++ --*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// A intra-procedural analysis for checking consumed properties. This is based,
> +// in part, on research on linear types.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "clang/AST/ASTContext.h"
> +#include "clang/AST/Attr.h"
> +#include "clang/AST/DeclCXX.h"
> +#include "clang/AST/ExprCXX.h"
> +#include "clang/AST/RecursiveASTVisitor.h"
> +#include "clang/AST/StmtVisitor.h"
> +#include "clang/AST/StmtCXX.h"
> +#include "clang/AST/Type.h"
> +#include "clang/Analysis/Analyses/PostOrderCFGView.h"
> +#include "clang/Analysis/AnalysisContext.h"
> +#include "clang/Analysis/CFG.h"
> +#include "clang/Analysis/Analyses/Consumed.h"
> +#include "clang/Basic/OperatorKinds.h"
> +#include "clang/Basic/SourceLocation.h"
> +#include "clang/Sema/ConsumedWarningsHandler.h"
> +#include "clang/Sema/SemaDiagnostic.h"
> +#include "llvm/ADT/DenseMap.h"
> +#include "llvm/ADT/SmallVector.h"
> +#include "llvm/Support/raw_ostream.h"
> +
> +// TODO: Add support for methods with CallableWhenUnconsumed.
> +// TODO: Mark variables as Unknown going into while- or for-loops only if they
> +// are referenced inside that block. (Deferred)
> +// TODO: Add a method(s) to identify which method calls perform what state
> +// transitions. (Deferred)
> +// TODO: Take notes on state transitions to provide better warning messages.
> +// (Deferred)
> +// TODO: Test nested conditionals: A) Checking the same value multiple times,
> +// and 2) Checking different values. (Deferred)
> +// TODO: Test IsFalseVisitor with values in the unknown state. (Deferred)
> +// TODO: Look into combining IsFalseVisitor and TestedVarsVisitor. (Deferred)
> +
> +using namespace clang;
> +using namespace consumed;
> +
> +// Key method definition
> +ConsumedWarningsHandlerBase::~ConsumedWarningsHandlerBase() {}
> +
> +static StringRef stateToString(ConsumedState State) {
> + switch (State) {
> + case consumed::CS_None:
> + return "none";
> +
> + case consumed::CS_Unknown:
> + return "unknown";
> +
> + case consumed::CS_Unconsumed:
> + return "unconsumed";
> +
> + case consumed::CS_Consumed:
> + return "consumed";
> + }
> +}
> +
> +namespace {
> +class ConsumedStmtVisitor : public ConstStmtVisitor<ConsumedStmtVisitor> {
> +
> + union PropagationUnion {
> + ConsumedState State;
> + const VarDecl *Var;
> + };
> +
> + class PropagationInfo {
> + PropagationUnion StateOrVar;
> +
> + public:
> + bool IsVar;
> +
> + PropagationInfo() : IsVar(false) {
> + StateOrVar.State = consumed::CS_None;
> + }
> +
> + PropagationInfo(ConsumedState State) : IsVar(false) {
> + StateOrVar.State = State;
> + }
> +
> + PropagationInfo(const VarDecl *Var) : IsVar(true) {
> + StateOrVar.Var = Var;
> + }
> +
> + ConsumedState getState() { return StateOrVar.State; };
> +
> + const VarDecl * getVar() { return IsVar ? StateOrVar.Var : NULL; };
> + };
> +
> + typedef llvm::DenseMap<const Stmt *, PropagationInfo> MapType;
> + typedef std::pair<const Stmt *, PropagationInfo> PairType;
> + typedef MapType::iterator InfoEntry;
> +
> + ConsumedAnalyzer &Analyzer;
> + ConsumedStateMap *StateMap;
> + MapType PropagationMap;
> +
> + void forwardInfo(const Stmt *From, const Stmt *To);
> + bool isLikeMoveAssignment(const CXXMethodDecl *MethodDecl);
> +
> +public:
> +
> + void Visit(const Stmt *StmtNode);
> +
> + void VisitBinaryOperator(const BinaryOperator *BinOp);
> + void VisitCallExpr(const CallExpr *Call);
> + void VisitCastExpr(const CastExpr *Cast);
> + void VisitCXXConstructExpr(const CXXConstructExpr *Call);
> + void VisitCXXMemberCallExpr(const CXXMemberCallExpr *Call);
> + void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Call);
> + void VisitDeclRefExpr(const DeclRefExpr *DeclRef);
> + void VisitDeclStmt(const DeclStmt *DelcS);
> + void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Temp);
> + void VisitMemberExpr(const MemberExpr *MExpr);
> + void VisitUnaryOperator(const UnaryOperator *UOp);
> + void VisitVarDecl(const VarDecl *Var);
> +
> + ConsumedStmtVisitor(ConsumedAnalyzer &Analyzer, ConsumedStateMap *StateMap) :
> + Analyzer(Analyzer), StateMap(StateMap) {}
> +
> + void reset() {
> + PropagationMap.clear();
> + }
> +};
> +
> +void ConsumedStmtVisitor::forwardInfo(const Stmt *From, const Stmt *To) {
> + InfoEntry Entry = PropagationMap.find(From);
> +
> + if (Entry != PropagationMap.end()) {
> + PropagationMap.insert(PairType(To, PropagationInfo(Entry->second)));
> + }
> +}
> +
> +bool ConsumedStmtVisitor::isLikeMoveAssignment(
> + const CXXMethodDecl *MethodDecl) {
> +
> + return MethodDecl->isMoveAssignmentOperator() ||
> + (MethodDecl->getOverloadedOperator() == OO_Equal &&
> + MethodDecl->getNumParams() == 1 &&
> + MethodDecl->getParamDecl(0)->getType()->isRValueReferenceType());
> +}
> +
> +void ConsumedStmtVisitor::VisitBinaryOperator(const BinaryOperator *BinOp) {
> + switch (BinOp->getOpcode()) {
> + case BO_PtrMemD:
> + case BO_PtrMemI:
> + forwardInfo(BinOp->getLHS(), BinOp);
> + break;
> +
> + default:
> + break;
> + }
> +}
> +
> +void ConsumedStmtVisitor::Visit(const Stmt *StmtNode) {
> + ConstStmtVisitor::Visit(StmtNode);
> +
> + for (Stmt::const_child_iterator CI = StmtNode->child_begin(),
> + CE = StmtNode->child_end(); CI != CE; ++CI) {
> +
> + PropagationMap.erase(*CI);
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitCallExpr(const CallExpr *Call) {
> + if (const FunctionDecl *FunDecl =
> + dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee())) {
> +
> + // Special case for the std::move function.
> + // TODO: Make this more specific. (Deferred)
> + if (FunDecl->getNameAsString() == "move") {
> + InfoEntry Entry = PropagationMap.find(Call->getArg(0));
> +
> + if (Entry != PropagationMap.end()) {
> + PropagationMap.insert(PairType(Call, Entry->second));
> + }
> +
> + return;
> + }
> +
> + unsigned Offset = Call->getNumArgs() - FunDecl->getNumParams();
> +
> + for (unsigned Index = Offset; Index < Call->getNumArgs(); ++Index) {
> + QualType ParamType = FunDecl->getParamDecl(Index - Offset)->getType();
> +
> + InfoEntry Entry = PropagationMap.find(Call->getArg(Index));
> +
> + if (Entry == PropagationMap.end() || !Entry->second.IsVar) {
> + continue;
> + }
> +
> + PropagationInfo PState = Entry->second;
> +
> + if (ParamType->isRValueReferenceType() ||
> + (ParamType->isLValueReferenceType() &&
> + !cast<LValueReferenceType>(*ParamType).isSpelledAsLValue())) {
> +
> + StateMap->setState(PState.getVar(), consumed::CS_Consumed);
> +
> + } else if (!(ParamType.isConstQualified() ||
> + ((ParamType->isReferenceType() ||
> + ParamType->isPointerType()) &&
> + ParamType->getPointeeType().isConstQualified()))) {
> +
> + StateMap->setState(PState.getVar(), consumed::CS_Unknown);
> + }
> + }
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitCastExpr(const CastExpr *Cast) {
> + InfoEntry Entry = PropagationMap.find(Cast->getSubExpr());
> +
> + if (Entry != PropagationMap.end())
> + PropagationMap.insert(PairType(Cast, Entry->second));
> +}
> +
> +void ConsumedStmtVisitor::VisitCXXConstructExpr(const CXXConstructExpr *Call) {
> + CXXConstructorDecl *Constructor = Call->getConstructor();
> +
> + ASTContext &CurrContext = Analyzer.getSema().getASTContext();
> + QualType ThisType = Constructor->getThisType(CurrContext)->getPointeeType();
> +
> + if (Analyzer.isConsumableType(ThisType)) {
> + if (Constructor->hasAttr<ConsumesAttr>() ||
> + Constructor->isDefaultConstructor()) {
> +
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(consumed::CS_Consumed)));
> +
> + } else if (Constructor->isMoveConstructor()) {
> +
> + PropagationInfo PState =
> + PropagationMap.find(Call->getArg(0))->second;
> +
> + if (PState.IsVar) {
> + const VarDecl* Var = PState.getVar();
> +
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(StateMap->getState(Var))));
> +
> + StateMap->setState(Var, consumed::CS_Consumed);
> +
> + } else {
> + PropagationMap.insert(PairType(Call, PState));
> + }
> +
> + } else if (Constructor->isCopyConstructor()) {
> + MapType::iterator Entry = PropagationMap.find(Call->getArg(0));
> +
> + if (Entry != PropagationMap.end())
> + PropagationMap.insert(PairType(Call, Entry->second));
> +
> + } else {
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(consumed::CS_Unconsumed)));
> + }
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitCXXMemberCallExpr(
> + const CXXMemberCallExpr *Call) {
> +
> + VisitCallExpr(Call);
> +
> + InfoEntry Entry = PropagationMap.find(Call->getCallee()->IgnoreParens());
> +
> + if (Entry != PropagationMap.end()) {
> + PropagationInfo PState = Entry->second;
> + if (!PState.IsVar) return;
> +
> + const CXXMethodDecl *Method = Call->getMethodDecl();
> +
> + if (Method->hasAttr<ConsumesAttr>())
> + StateMap->setState(PState.getVar(), consumed::CS_Consumed);
> + else if (!Method->isConst())
> + StateMap->setState(PState.getVar(), consumed::CS_Unknown);
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitCXXOperatorCallExpr(
> + const CXXOperatorCallExpr *Call) {
> +
> + const FunctionDecl *FunDecl =
> + dyn_cast_or_null<FunctionDecl>(Call->getDirectCallee());
> +
> + if (!FunDecl) return;
> +
> + if (isa<CXXMethodDecl>(FunDecl) &&
> + isLikeMoveAssignment(cast<CXXMethodDecl>(FunDecl))) {
> +
> + InfoEntry LEntry = PropagationMap.find(Call->getArg(0));
> + InfoEntry REntry = PropagationMap.find(Call->getArg(1));
> +
> + PropagationInfo LPState, RPState;
> +
> + if (LEntry != PropagationMap.end() &&
> + REntry != PropagationMap.end()) {
> +
> + LPState = LEntry->second;
> + RPState = REntry->second;
> +
> + if (LPState.IsVar && RPState.IsVar) {
> + StateMap->setState(LPState.getVar(),
> + StateMap->getState(RPState.getVar()));
> +
> + StateMap->setState(RPState.getVar(), consumed::CS_Consumed);
> +
> + PropagationMap.insert(PairType(Call, LPState));
> +
> + } else if (LPState.IsVar && !RPState.IsVar) {
> + StateMap->setState(LPState.getVar(), RPState.getState());
> +
> + PropagationMap.insert(PairType(Call, LPState));
> +
> + } else if (!LPState.IsVar && RPState.IsVar) {
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(StateMap->getState(RPState.getVar()))));
> +
> + StateMap->setState(RPState.getVar(), consumed::CS_Consumed);
> +
> + } else {
> + PropagationMap.insert(PairType(Call, RPState));
> + }
> +
> + } else if (LEntry != PropagationMap.end() &&
> + REntry == PropagationMap.end()) {
> +
> + LPState = LEntry->second;
> +
> + if (LPState.IsVar) {
> + StateMap->setState(LPState.getVar(), consumed::CS_Unknown);
> +
> + PropagationMap.insert(PairType(Call, LPState));
> +
> + } else {
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(consumed::CS_Unknown)));
> + }
> +
> + } else if (LEntry == PropagationMap.end() &&
> + REntry != PropagationMap.end()) {
> +
> + RPState = REntry->second;
> +
> + if (RPState.IsVar) {
> + const VarDecl *Var = RPState.getVar();
> +
> + PropagationMap.insert(PairType(Call,
> + PropagationInfo(StateMap->getState(Var))));
> +
> + StateMap->setState(Var, consumed::CS_Consumed);
> +
> + } else {
> + PropagationMap.insert(PairType(Call, RPState));
> + }
> + }
> +
> + } else {
> +
> + VisitCallExpr(Call);
> +
> + InfoEntry Entry = PropagationMap.find(Call->getArg(0));
> +
> + if (Entry != PropagationMap.end()) {
> +
> + PropagationInfo PState = Entry->second;
> +
> + // TODO: When we support CallableWhenConsumed this will have to check for
> + // the different attributes and change the behavior bellow.
> + // (Deferred)
> + if (FunDecl->hasAttr<CallableWhenUnconsumedAttr>()) {
> + if (PState.IsVar) {
> + const VarDecl *Var = PState.getVar();
> +
> + switch (StateMap->getState(Var)) {
> + case CS_Consumed:
> + Analyzer.WarningsHandler.warnUseWhileConsumed(
> + FunDecl->getNameAsString(), Var->getNameAsString(),
> + Call->getExprLoc());
> + break;
> +
> + case CS_Unknown:
> + Analyzer.WarningsHandler.warnUseInUnknownState(
> + FunDecl->getNameAsString(), Var->getNameAsString(),
> + Call->getExprLoc());
> + break;
> +
> + default:
> + break;
> + }
> +
> + } else {
> + switch (PState.getState()) {
> + case CS_Consumed:
> + Analyzer.WarningsHandler.warnUseOfTempWhileConsumed(
> + FunDecl->getNameAsString(), Call->getExprLoc());
> + break;
> +
> + case CS_Unknown:
> + Analyzer.WarningsHandler.warnUseOfTempInUnknownState(
> + FunDecl->getNameAsString(), Call->getExprLoc());
> + break;
> +
> + default:
> + break;
> + }
> + }
> + }
> +
> + // Handle non-constant member operators.
> + if (const CXXMethodDecl *MethodDecl =
> + dyn_cast_or_null<CXXMethodDecl>(FunDecl)) {
> +
> + if (!MethodDecl->isConst() && PState.IsVar)
> + StateMap->setState(PState.getVar(), consumed::CS_Unknown);
> + }
> + }
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitDeclRefExpr(const DeclRefExpr *DeclRef) {
> + if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(DeclRef->getDecl()))
> + if (StateMap->getState(Var) != consumed::CS_None)
> + PropagationMap.insert(PairType(DeclRef, PropagationInfo(Var)));
> +}
> +
> +void ConsumedStmtVisitor::VisitDeclStmt(const DeclStmt *DeclS) {
> + for (DeclStmt::const_decl_iterator DI = DeclS->decl_begin(),
> + DE = DeclS->decl_end(); DI != DE; ++DI) {
> +
> + if (isa<VarDecl>(*DI)) VisitVarDecl(cast<VarDecl>(*DI));
> + }
> +
> + if (DeclS->isSingleDecl())
> + if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(DeclS->getSingleDecl()))
> + PropagationMap.insert(PairType(DeclS, PropagationInfo(Var)));
> +}
> +
> +void ConsumedStmtVisitor::VisitMaterializeTemporaryExpr(
> + const MaterializeTemporaryExpr *Temp) {
> +
> + InfoEntry Entry = PropagationMap.find(Temp->GetTemporaryExpr());
> +
> + if (Entry != PropagationMap.end())
> + PropagationMap.insert(PairType(Temp, Entry->second));
> +}
> +
> +void ConsumedStmtVisitor::VisitMemberExpr(const MemberExpr *MExpr) {
> + forwardInfo(MExpr->getBase(), MExpr);
> +}
> +
> +void ConsumedStmtVisitor::VisitUnaryOperator(const UnaryOperator *UOp) {
> + if (UOp->getOpcode() == UO_AddrOf) {
> + InfoEntry Entry = PropagationMap.find(UOp->getSubExpr());
> +
> + if (Entry != PropagationMap.end())
> + PropagationMap.insert(PairType(UOp, Entry->second));
> + }
> +}
> +
> +void ConsumedStmtVisitor::VisitVarDecl(const VarDecl *Var) {
> + if (Analyzer.isConsumableType(Var->getType())) {
> + PropagationInfo PState =
> + PropagationMap.find(Var->getInit())->second;
> +
> + StateMap->setState(Var, PState.IsVar ?
> + StateMap->getState(PState.getVar()) : PState.getState());
> + }
> +}
> +} // end anonymous::ConsumedStmtVisitor
> +
> +namespace {
> +
> +// TODO: Handle variable definitions, e.g. bool valid = x.isValid();
> +// if (valid) ...; (Deferred)
> +class TestedVarsVisitor : public RecursiveASTVisitor<TestedVarsVisitor> {
> +
> + bool Invert;
> + SourceLocation CurrTestLoc;
> +
> + ConsumedStateMap *StateMap;
> +
> +public:
> + bool IsUsefulConditional;
> + VarTestResult Test;
> +
> + TestedVarsVisitor(ConsumedStateMap *StateMap) : Invert(false),
> + StateMap(StateMap), IsUsefulConditional(false) {}
> +
> + bool VisitCallExpr(CallExpr *Call);
> + bool VisitDeclRefExpr(DeclRefExpr *DeclRef);
> + bool VisitUnaryOperator(UnaryOperator *UnaryOp);
> +};
> +
> +bool TestedVarsVisitor::VisitCallExpr(CallExpr *Call) {
> + if (const CXXMethodDecl *Method =
> + dyn_cast_or_null<CXXMethodDecl>(Call->getDirectCallee())) {
> +
> + if (isTestingFunction(Method)) {
> + CurrTestLoc = Call->getExprLoc();
> + IsUsefulConditional = true;
> + return true;
> + }
> +
> + IsUsefulConditional = false;
> + }
> +
> + return false;
> +}
> +
> +bool TestedVarsVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
> + if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(DeclRef->getDecl())) {
> + if (StateMap->getState(Var) != consumed::CS_None) {
> + Test = VarTestResult(Var, CurrTestLoc, !Invert);
> + }
> +
> + } else {
> + IsUsefulConditional = false;
> + }
> +
> + return IsUsefulConditional;
> +}
> +
> +bool TestedVarsVisitor::VisitUnaryOperator(UnaryOperator *UnaryOp) {
> + if (UnaryOp->getOpcode() == UO_LNot) {
> + Invert = true;
> + TraverseStmt(UnaryOp->getSubExpr());
> +
> + } else {
> + IsUsefulConditional = false;
> + }
> +
> + return false;
> +}
> +} // end anonymouse::TestedVarsVisitor
> +
> +namespace clang {
> +namespace consumed {
> +
> +void ConsumedBlockInfo::addInfo(const CFGBlock *Block,
> + ConsumedStateMap *StateMap,
> + bool &AlreadyOwned) {
> +
> + if (VisitedBlocks.alreadySet(Block)) return;
> +
> + ConsumedStateMap *Entry = StateMapsArray[Block->getBlockID()];
> +
> + if (Entry) {
> + Entry->intersect(StateMap);
> +
> + } else if (AlreadyOwned) {
> + StateMapsArray[Block->getBlockID()] = new ConsumedStateMap(*StateMap);
> +
> + } else {
> + StateMapsArray[Block->getBlockID()] = StateMap;
> + AlreadyOwned = true;
> + }
> +}
> +
> +void ConsumedBlockInfo::addInfo(const CFGBlock *Block,
> + ConsumedStateMap *StateMap) {
> +
> + if (VisitedBlocks.alreadySet(Block)) {
> + delete StateMap;
> + return;
> + }
> +
> + ConsumedStateMap *Entry = StateMapsArray[Block->getBlockID()];
> +
> + if (Entry) {
> + Entry->intersect(StateMap);
> + delete StateMap;
> +
> + } else {
> + StateMapsArray[Block->getBlockID()] = StateMap;
> + }
> +}
> +
> +ConsumedStateMap* ConsumedBlockInfo::getInfo(const CFGBlock *Block) {
> + return StateMapsArray[Block->getBlockID()];
> +}
> +
> +void ConsumedBlockInfo::markVisited(const CFGBlock *Block) {
> + VisitedBlocks.insert(Block);
> +}
> +
> +ConsumedState ConsumedStateMap::getState(const VarDecl *Var) {
> + MapType::const_iterator Entry = Map.find(Var);
> +
> + if (Entry != Map.end()) {
> + return Entry->second;
> +
> + } else {
> + return CS_None;
> + }
> +}
> +
> +void ConsumedStateMap::intersect(const ConsumedStateMap *Other) {
> + ConsumedState LocalState;
> +
> + for (MapType::const_iterator DMI = Other->Map.begin(),
> + DME = Other->Map.end(); DMI != DME; ++DMI) {
> +
> + LocalState = this->getState(DMI->first);
> +
> + if (LocalState != CS_None && LocalState != DMI->second)
> + setState(DMI->first, CS_Unknown);
> + }
> +}
> +
> +void ConsumedStateMap::makeUnknown() {
> + PairType Pair;
> +
> + for (MapType::const_iterator DMI = Map.begin(), DME = Map.end(); DMI != DME;
> + ++DMI) {
> +
> + Pair = *DMI;
> +
> + Map.erase(Pair.first);
> + Map.insert(PairType(Pair.first, CS_Unknown));
> + }
> +}
> +
> +void ConsumedStateMap::setState(const VarDecl *Var, ConsumedState State) {
> + Map[Var] = State;
> +}
> +
> +const Sema & ConsumedAnalyzer::getSema() {
> + return S;
> +}
> +
> +
> +bool ConsumedAnalyzer::isConsumableType(QualType Type) {
> + const CXXRecordDecl *RD =
> + dyn_cast_or_null<CXXRecordDecl>(Type->getAsCXXRecordDecl());
> +
> + if (!RD) return false;
> +
> + std::pair<CacheMapType::iterator, bool> Entry =
> + ConsumableTypeCache.insert(std::make_pair(RD, false));
> +
> + if (Entry.second)
> + Entry.first->second = hasConsumableAttributes(RD);
> +
> + return Entry.first->second;
> +}
> +
> +// TODO: Walk the base classes to see if any of them are unique types.
> +// (Deferred)
> +bool ConsumedAnalyzer::hasConsumableAttributes(const CXXRecordDecl *RD) {
> + for (CXXRecordDecl::method_iterator MI = RD->method_begin(),
> + ME = RD->method_end(); MI != ME; ++MI) {
> +
> + for (Decl::attr_iterator AI = (*MI)->attr_begin(), AE = (*MI)->attr_end();
> + AI != AE; ++AI) {
> +
> + switch ((*AI)->getKind()) {
> + case attr::CallableWhenUnconsumed:
> + case attr::TestsUnconsumed:
> + return true;
> +
> + default:
> + break;
> + }
> + }
> + }
> +
> + return false;
> +}
> +
> +// TODO: Handle other forms of branching with precision, including while- and
> +// for-loops. (Deferred)
> +void ConsumedAnalyzer::splitState(const CFGBlock *CurrBlock,
> + const IfStmt *Terminator) {
> +
> + TestedVarsVisitor Visitor(CurrStates);
> + Visitor.TraverseStmt(const_cast<Expr*>(Terminator->getCond()));
> +
> + bool HasElse = Terminator->getElse() != NULL;
> +
> + ConsumedStateMap *ElseOrMergeStates = new ConsumedStateMap(*CurrStates);
> +
> + if (Visitor.IsUsefulConditional) {
> + ConsumedState VarState = CurrStates->getState(Visitor.Test.Var);
> +
> + if (VarState != CS_Unknown) {
> + // FIXME: Make this not warn if the test is from a macro expansion.
> + // (Deferred)
> + WarningsHandler.warnUnnecessaryTest(Visitor.Test.Var->getNameAsString(),
> + stateToString(VarState), Visitor.Test.Loc);
> + }
> +
> + if (Visitor.Test.UnconsumedInTrueBranch) {
> + CurrStates->setState(Visitor.Test.Var, CS_Unconsumed);
> + if (HasElse) ElseOrMergeStates->setState(Visitor.Test.Var, CS_Consumed);
> +
> + } else {
> + CurrStates->setState(Visitor.Test.Var, CS_Consumed);
> + if (HasElse) ElseOrMergeStates->setState(Visitor.Test.Var, CS_Unconsumed);
> + }
> + }
> +
> + CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin();
> +
> + if (*SI) BlockInfo.addInfo(*SI, CurrStates);
> + if (*++SI) BlockInfo.addInfo(*SI, ElseOrMergeStates);
> +}
> +
> +void ConsumedAnalyzer::run(AnalysisDeclContext &AC) {
> + const FunctionDecl *D = dyn_cast_or_null<FunctionDecl>(AC.getDecl());
> +
> + if (!D) return;
> +
> + BlockInfo = ConsumedBlockInfo(AC.getCFG());
> +
> + PostOrderCFGView *SortedGraph = AC.getAnalysis<PostOrderCFGView>();
> +
> + CurrStates = new ConsumedStateMap();
> +
> + // Visit all of the function's basic blocks.
> + for (PostOrderCFGView::iterator I = SortedGraph->begin(),
> + E = SortedGraph->end(); I != E; ++I) {
> +
> + const CFGBlock *CurrBlock = *I;
> + BlockInfo.markVisited(CurrBlock);
> +
> + if (CurrStates == NULL)
> + CurrStates = BlockInfo.getInfo(CurrBlock);
> +
> + ConsumedStmtVisitor Visitor(*this, CurrStates);
> +
> + // Visit all of the basic block's statements.
> + for (CFGBlock::const_iterator BI = CurrBlock->begin(),
> + BE = CurrBlock->end(); BI != BE; ++BI) {
> +
> + if (BI->getKind() == CFGElement::Statement)
> + Visitor.Visit(BI->castAs<CFGStmt>().getStmt());
> + }
> +
> + // TODO: Remove any variables that have reached the end of their
> + // lifetimes from the state map. (Deferred)
> +
> + if (const IfStmt *Terminator =
> + dyn_cast_or_null<IfStmt>(CurrBlock->getTerminator().getStmt())) {
> +
> + splitState(CurrBlock, Terminator);
> + CurrStates = NULL;
> +
> + } else if (CurrBlock->succ_size() > 1) {
> + CurrStates->makeUnknown();
> +
> + bool OwnershipTaken = false;
> +
> + for (CFGBlock::const_succ_iterator SI = CurrBlock->succ_begin(),
> + SE = CurrBlock->succ_end(); SI != SE; ++SI) {
> +
> + if (*SI) BlockInfo.addInfo(*SI, CurrStates, OwnershipTaken);
> + }
> +
> + if (!OwnershipTaken)
> + delete CurrStates;
> +
> + CurrStates = NULL;
> +
> + } else if (CurrBlock->succ_size() == 1 &&
> + (*CurrBlock->succ_begin())->pred_size() > 1) {
> +
> + BlockInfo.addInfo(*CurrBlock->succ_begin(), CurrStates);
> + CurrStates = NULL;
> + }
> +
> + Visitor.reset();
> + } // End of block iterator.
> +
> + // Delete the last existing state map.
> + delete CurrStates;
> +
> + WarningsHandler.emitDiagnostics();
> +}
> +
> +unsigned checkEnabled(DiagnosticsEngine &D) {
> + return (unsigned)
> + (D.getDiagnosticLevel(diag::warn_use_while_consumed, SourceLocation()) !=
> + DiagnosticsEngine::Ignored);
> +}
> +
> +bool isTestingFunction(const CXXMethodDecl *Method) {
> + return Method->hasAttr<TestsUnconsumedAttr>();
> +}
> +
> +}} // end namespace clang::consumed
>
> Modified: cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp (original)
> +++ cfe/trunk/lib/Sema/AnalysisBasedWarnings.cpp Mon Aug 12 16:20:55 2013
> @@ -25,6 +25,7 @@
> #include "clang/AST/StmtObjC.h"
> #include "clang/AST/StmtVisitor.h"
> #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h"
> +#include "clang/Analysis/Analyses/Consumed.h"
> #include "clang/Analysis/Analyses/ReachableCode.h"
> #include "clang/Analysis/Analyses/ThreadSafety.h"
> #include "clang/Analysis/Analyses/UninitializedValues.h"
> @@ -1241,12 +1242,8 @@ private:
> };
> }
>
> -
> -//===----------------------------------------------------------------------===//
> -// -Wthread-safety
> -//===----------------------------------------------------------------------===//
> namespace clang {
> -namespace thread_safety {
> +namespace {
> typedef SmallVector<PartialDiagnosticAt, 1> OptionalNotes;
> typedef std::pair<PartialDiagnosticAt, OptionalNotes> DelayedDiag;
> typedef std::list<DelayedDiag> DiagList;
> @@ -1261,7 +1258,13 @@ struct SortDiagBySourceLocation {
> return SM.isBeforeInTranslationUnit(left.first.first, right.first.first);
> }
> };
> +}}
>
> +//===----------------------------------------------------------------------===//
> +// -Wthread-safety
> +//===----------------------------------------------------------------------===//
> +namespace clang {
> +namespace thread_safety {
> namespace {
> class ThreadSafetyReporter : public clang::thread_safety::ThreadSafetyHandler {
> Sema &S;
> @@ -1412,6 +1415,119 @@ class ThreadSafetyReporter : public clan
> }
>
> //===----------------------------------------------------------------------===//
> +// -Wconsumed
> +//===----------------------------------------------------------------------===//
> +
> +namespace clang {
> +namespace consumed {
> +namespace {
> +class ConsumedWarningsHandler : public ConsumedWarningsHandlerBase {
> +
> + Sema &S;
> + DiagList Warnings;
> +
> +public:
> +
> + ConsumedWarningsHandler(Sema &S) : S(S) {}
> +
> + void emitDiagnostics() {
> + Warnings.sort(SortDiagBySourceLocation(S.getSourceManager()));
> +
> + for (DiagList::iterator I = Warnings.begin(), E = Warnings.end();
> + I != E; ++I) {
> +
> + const OptionalNotes &Notes = I->second;
> + S.Diag(I->first.first, I->first.second);
> +
> + for (unsigned NoteI = 0, NoteN = Notes.size(); NoteI != NoteN; ++NoteI) {
> + S.Diag(Notes[NoteI].first, Notes[NoteI].second);
> + }
> + }
> + }
> +
> + /// Warn about unnecessary-test errors.
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the unnecessary test.
> + void warnUnnecessaryTest(StringRef VariableName, StringRef VariableState,
> + SourceLocation Loc) {
> +
> + PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_unnecessary_test) <<
> + VariableName << VariableState);
> +
> + Warnings.push_back(DelayedDiag(Warning, OptionalNotes()));
> + }
> +
> + /// Warn about use-while-consumed errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + void warnUseOfTempWhileConsumed(StringRef MethodName, SourceLocation Loc) {
> +
> + PartialDiagnosticAt Warning(Loc, S.PDiag(
> + diag::warn_use_of_temp_while_consumed) << MethodName);
> +
> + Warnings.push_back(DelayedDiag(Warning, OptionalNotes()));
> + }
> +
> + /// Warn about use-in-unknown-state errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + void warnUseOfTempInUnknownState(StringRef MethodName, SourceLocation Loc) {
> +
> + PartialDiagnosticAt Warning(Loc, S.PDiag(
> + diag::warn_use_of_temp_in_unknown_state) << MethodName);
> +
> + Warnings.push_back(DelayedDiag(Warning, OptionalNotes()));
> + }
> +
> + /// Warn about use-while-consumed errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + void warnUseWhileConsumed(StringRef MethodName, StringRef VariableName,
> + SourceLocation Loc) {
> +
> + PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_use_while_consumed) <<
> + MethodName << VariableName);
> +
> + Warnings.push_back(DelayedDiag(Warning, OptionalNotes()));
> + }
> +
> + /// Warn about use-in-unknown-state errors.
> + /// \param MethodName -- The name of the method that was incorrectly
> + /// invoked.
> + ///
> + /// \param VariableName -- The name of the variable that holds the unique
> + /// value.
> + ///
> + /// \param Loc -- The SourceLocation of the method invocation.
> + void warnUseInUnknownState(StringRef MethodName, StringRef VariableName,
> + SourceLocation Loc) {
> +
> + PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_use_in_unknown_state) <<
> + MethodName << VariableName);
> +
> + Warnings.push_back(DelayedDiag(Warning, OptionalNotes()));
> + }
> +};
> +}}}
> +
> +//===----------------------------------------------------------------------===//
> // AnalysisBasedWarnings - Worker object used by Sema to execute analysis-based
> // warnings on a function, method, or block.
> //===----------------------------------------------------------------------===//
> @@ -1420,6 +1536,7 @@ clang::sema::AnalysisBasedWarnings::Poli
> enableCheckFallThrough = 1;
> enableCheckUnreachable = 0;
> enableThreadSafetyAnalysis = 0;
> + enableConsumedAnalysis = 0;
> }
>
> clang::sema::AnalysisBasedWarnings::AnalysisBasedWarnings(Sema &s)
> @@ -1440,6 +1557,7 @@ clang::sema::AnalysisBasedWarnings::Anal
> DefaultPolicy.enableThreadSafetyAnalysis = (unsigned)
> (D.getDiagnosticLevel(diag::warn_double_lock, SourceLocation()) !=
> DiagnosticsEngine::Ignored);
> + DefaultPolicy.enableConsumedAnalysis = consumed::checkEnabled(D);
>
> }
>
> @@ -1501,7 +1619,8 @@ AnalysisBasedWarnings::IssueWarnings(sem
> // prototyping, but we need a way for analyses to say what expressions they
> // expect to always be CFGElements and then fill in the BuildOptions
> // appropriately. This is essentially a layering violation.
> - if (P.enableCheckUnreachable || P.enableThreadSafetyAnalysis) {
> + if (P.enableCheckUnreachable || P.enableThreadSafetyAnalysis ||
> + P.enableConsumedAnalysis) {
> // Unreachable code analysis and thread safety require a linearized CFG.
> AC.getCFGBuildOptions().setAllAlwaysAdd();
> }
> @@ -1605,6 +1724,13 @@ AnalysisBasedWarnings::IssueWarnings(sem
> Reporter.emitDiagnostics();
> }
>
> + // Check for violations of consumed properties.
> + if (P.enableConsumedAnalysis) {
> + consumed::ConsumedWarningsHandler WarningHandler(S);
> + consumed::ConsumedAnalyzer Analyzer(S, WarningHandler);
> + Analyzer.run(AC);
> + }
> +
> if (Diags.getDiagnosticLevel(diag::warn_uninit_var, D->getLocStart())
> != DiagnosticsEngine::Ignored ||
> Diags.getDiagnosticLevel(diag::warn_sometimes_uninit_var,D->getLocStart())
>
> Modified: cfe/trunk/lib/Sema/SemaDeclAttr.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclAttr.cpp?rev=188206&r1=188205&r2=188206&view=diff
> ==============================================================================
> --- cfe/trunk/lib/Sema/SemaDeclAttr.cpp (original)
> +++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp Mon Aug 12 16:20:55 2013
> @@ -997,6 +997,69 @@ static void handleLocksExcludedAttr(Sema
> Attr.getAttributeSpellingListIndex()));
> }
>
> +static void handleConsumesAttr(Sema &S, Decl *D,
> + const AttributeList &Attr) {
> + assert(!Attr.isInvalid());
The assert is superfluous here and elsewhere (see ProcessDeclAttribute
where invalid attributes are early-returned).
> + if (!checkAttributeNumArgs(S, Attr, 0)) return;
> +
> + if (!(isa<CXXMethodDecl>(D) || isa<CXXConstructorDecl>(D))) {
> + S.Diag(Attr.getLoc(), diag::warn_uniqueness_attribute_wrong_decl_type) <<
> + Attr.getName();
> + return;
> + }
Please update the attribute's subjects to match the predicate. Also,
is this really only valid for C++ functions? The given warning seems
to imply non-instance methods are also acceptable targets. If this
really is for C++ only methods, ensure the warning is updated to have
the proper wording. This also applies elsewhere.
> +
> + D->addAttr(::new (S.Context)
> + ConsumesAttr(Attr.getRange(), S.Context,
> + Attr.getAttributeSpellingListIndex()));
> +}
> +
> +static void handleCallableWhenUnconsumedAttr(Sema &S, Decl *D,
> + const AttributeList &Attr) {
> + assert(!Attr.isInvalid());
> + if (!checkAttributeNumArgs(S, Attr, 0)) return;
> +
> + if (!isa<CXXMethodDecl>(D)) {
> + S.Diag(Attr.getLoc(), diag::warn_uniqueness_attribute_wrong_decl_type) <<
> + Attr.getName();
> + return;
> + }
> +
> + D->addAttr(::new (S.Context)
> + CallableWhenUnconsumedAttr(Attr.getRange(), S.Context,
> + Attr.getAttributeSpellingListIndex()));
> +}
> +
> +static void handleTestsConsumedAttr(Sema &S, Decl *D,
> + const AttributeList &Attr) {
> + assert(!Attr.isInvalid());
> + if (!checkAttributeNumArgs(S, Attr, 0)) return;
> +
> + if (!isa<CXXMethodDecl>(D)) {
> + S.Diag(Attr.getLoc(), diag::warn_uniqueness_attribute_wrong_decl_type) <<
> + Attr.getName();
> + return;
> + }
> +
> + D->addAttr(::new (S.Context)
> + TestsConsumedAttr(Attr.getRange(), S.Context,
> + Attr.getAttributeSpellingListIndex()));
> +}
> +
> +static void handleTestsUnconsumedAttr(Sema &S, Decl *D,
> + const AttributeList &Attr) {
> + assert(!Attr.isInvalid());
> + if (!checkAttributeNumArgs(S, Attr, 0)) return;
> +
> + if (!isa<CXXMethodDecl>(D)) {
> + S.Diag(Attr.getLoc(), diag::warn_uniqueness_attribute_wrong_decl_type) <<
> + Attr.getName();
> + return;
> + }
> +
> + D->addAttr(::new (S.Context)
> + TestsUnconsumedAttr(Attr.getRange(), S.Context,
> + Attr.getAttributeSpellingListIndex()));
> +}
>
> static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
> const AttributeList &Attr) {
> @@ -4952,6 +5015,20 @@ static void ProcessInheritableDeclAttr(S
> handleAcquiredAfterAttr(S, D, Attr);
> break;
>
> + // Uniqueness analysis attributes.
> + case AttributeList::AT_Consumes:
> + handleConsumesAttr(S, D, Attr);
> + break;
> + case AttributeList::AT_CallableWhenUnconsumed:
> + handleCallableWhenUnconsumedAttr(S, D, Attr);
> + break;
> + case AttributeList::AT_TestsConsumed:
> + handleTestsConsumedAttr(S, D, Attr);
> + break;
> + case AttributeList::AT_TestsUnconsumed:
> + handleTestsUnconsumedAttr(S, D, Attr);
> + break;
> +
> // Type safety attributes.
> case AttributeList::AT_ArgumentWithTypeTag:
> handleArgumentWithTypeTagAttr(S, D, Attr);
>
> Added: cfe/trunk/test/SemaCXX/warn-consumed-analysis-strict.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/warn-consumed-analysis-strict.cpp?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/test/SemaCXX/warn-consumed-analysis-strict.cpp (added)
> +++ cfe/trunk/test/SemaCXX/warn-consumed-analysis-strict.cpp Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,123 @@
> +// RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed-strict -std=c++11 %s
> +
> +#define CALLABLE_WHEN_UNCONSUMED __attribute__ ((callable_when_unconsumed))
> +#define CONSUMES __attribute__ ((consumes))
> +#define TESTS_UNCONSUMED __attribute__ ((tests_unconsumed))
> +
> +typedef decltype(nullptr) nullptr_t;
> +
> +template <typename T>
> +class Bar {
> + T var;
> +
> + public:
> + Bar(void);
> + Bar(T val);
> + Bar(Bar<T> &other);
> + Bar(Bar<T> &&other);
> +
> + Bar<T>& operator=(Bar<T> &other);
> + Bar<T>& operator=(Bar<T> &&other);
> + Bar<T>& operator=(nullptr_t);
> +
> + template <typename U>
> + Bar<T>& operator=(Bar<U> &other);
> +
> + template <typename U>
> + Bar<T>& operator=(Bar<U> &&other);
> +
> + void operator*(void) const CALLABLE_WHEN_UNCONSUMED;
> +
> + bool isValid(void) const TESTS_UNCONSUMED;
> +
> + void constCall(void) const;
> + void nonconstCall(void);
> +
> + void consume(void) CONSUMES;
> +};
> +
> +void baf0(Bar<int> &var);
> +void baf1(Bar<int> *var);
> +
> +void testIfStmt(void) {
> + Bar<int> var;
> +
> + if (var.isValid()) { // expected-warning {{unnecessary test. Variable 'var' is known to be in the 'consumed' state}}
> +
> + // Empty
> +
> + } else {
> + // Empty
> + }
> +}
> +
> +void testConditionalMerge(void) {
> + Bar<int> var;
> +
> + if (var.isValid()) {// expected-warning {{unnecessary test. Variable 'var' is known to be in the 'consumed' state}}
> +
> + // Empty
> + }
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +
> + if (var.isValid()) {
> + // Empty
> +
> + } else {
> + // Empty
> + }
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
> +
> +void testCallingConventions(void) {
> + Bar<int> var(42);
> +
> + baf0(var);
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +
> + var = Bar<int>(42);
> + baf1(&var);
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
> +
> +void testMoveAsignmentish(void) {
> + Bar<int> var;
> +
> + var = nullptr;
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
> +
> +void testConstAndNonConstMemberFunctions(void) {
> + Bar<int> var(42);
> +
> + var.constCall();
> + *var;
> +
> + var.nonconstCall();
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
> +
> +void testSimpleForLoop(void) {
> + Bar<int> var;
> +
> + for (int i = 0; i < 10; ++i) {
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> + }
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
> +
> +void testSimpleWhileLoop(void) {
> + int i = 0;
> +
> + Bar<int> var;
> +
> + while (i < 10) {
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> + ++i;
> + }
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in an unknown state}}
> +}
>
> Added: cfe/trunk/test/SemaCXX/warn-consumed-analysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/warn-consumed-analysis.cpp?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/test/SemaCXX/warn-consumed-analysis.cpp (added)
> +++ cfe/trunk/test/SemaCXX/warn-consumed-analysis.cpp Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,188 @@
> +// RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed -std=c++11 %s
> +
> +#define CALLABLE_WHEN_UNCONSUMED __attribute__ ((callable_when_unconsumed))
> +#define CONSUMES __attribute__ ((consumes))
> +#define TESTS_UNCONSUMED __attribute__ ((tests_unconsumed))
> +
> +typedef decltype(nullptr) nullptr_t;
> +
> +template <typename T>
> +class Bar {
> + T var;
> +
> + public:
> + Bar(void);
> + Bar(nullptr_t p) CONSUMES;
> + Bar(T val);
> + Bar(Bar<T> &other);
> + Bar(Bar<T> &&other);
> +
> + Bar<T>& operator=(Bar<T> &other);
> + Bar<T>& operator=(Bar<T> &&other);
> + Bar<T>& operator=(nullptr_t);
> +
> + template <typename U>
> + Bar<T>& operator=(Bar<U> &other);
> +
> + template <typename U>
> + Bar<T>& operator=(Bar<U> &&other);
> +
> + void operator*(void) const CALLABLE_WHEN_UNCONSUMED;
> +
> + bool isValid(void) const TESTS_UNCONSUMED;
> + operator bool() const TESTS_UNCONSUMED;
> +
> + void constCall(void) const;
> + void nonconstCall(void);
> +
> + void consume(void) CONSUMES;
> +};
> +
> +void baf0(const Bar<int> var);
> +void baf1(const Bar<int> &var);
> +void baf2(const Bar<int> *var);
> +
> +void baf3(Bar<int> &&var);
> +
> +void testInitialization(void) {
> + Bar<int> var0;
> + Bar<int> var1 = Bar<int>();
> +
> + var0 = Bar<int>();
> +
> + *var0; // expected-warning {{invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
> + *var1; // expected-warning {{invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
> +
> + if (var0.isValid()) {
> + *var0;
> + *var1; // expected-warning {{invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
> +
> + } else {
> + *var0; // expected-warning {{invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
> + }
> +}
> +
> +void testSimpleRValueRefs(void) {
> + Bar<int> var0;
> + Bar<int> var1(42);
> +
> + *var0; // expected-warning {{invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
> + *var1;
> +
> + var0 = static_cast<Bar<int>&&>(var1);
> +
> + *var0;
> + *var1; // expected-warning {{invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
> +}
> +
> +void testIfStmt(void) {
> + Bar<int> var;
> +
> + if (var.isValid()) {
> + // Empty
> +
> + } else {
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> + }
> +
> + if (!var.isValid()) {
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> +
> + } else {
> + *var;
> + }
> +
> + if (var) {
> + // Empty
> +
> + } else {
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> + }
> +}
> +
> +void testCallingConventions(void) {
> + Bar<int> var(42);
> +
> + baf0(var);
> + *var;
> +
> + baf1(var);
> + *var;
> +
> + baf2(&var);
> + *var;
> +
> + baf3(static_cast<Bar<int>&&>(var));
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> +}
> +
> +void testMoveAsignmentish(void) {
> + Bar<int> var0;
> + Bar<long> var1(42);
> +
> + *var0; // expected-warning {{invocation of method 'operator*' on object 'var0' while it is in the 'consumed' state}}
> + *var1;
> +
> + var0 = static_cast<Bar<long>&&>(var1);
> +
> + *var0;
> + *var1; // expected-warning {{invocation of method 'operator*' on object 'var1' while it is in the 'consumed' state}}
> +}
> +
> +void testConditionalMerge(void) {
> + Bar<int> var;
> +
> + if (var.isValid()) {
> + // Empty
> + }
> +
> + *var;
> +
> + if (var.isValid()) {
> + // Empty
> +
> + } else {
> + // Empty
> + }
> +
> + *var;
> +}
> +
> +void testConsumes0(void) {
> + Bar<int> var(42);
> +
> + *var;
> +
> + var.consume();
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> +}
> +
> +void testConsumes1(void) {
> + Bar<int> var(nullptr);
> +
> + *var; // expected-warning {{invocation of method 'operator*' on object 'var' while it is in the 'consumed' state}}
> +}
> +
> +void testSimpleForLoop(void) {
> + Bar<int> var;
> +
> + for (int i = 0; i < 10; ++i) {
> + *var;
> + }
> +
> + *var;
> +}
> +
> +void testSimpleWhileLoop(void) {
> + int i = 0;
> +
> + Bar<int> var;
> +
> + while (i < 10) {
> + *var;
> + ++i;
> + }
> +
> + *var;
> +}
>
> Added: cfe/trunk/test/SemaCXX/warn-consumed-parsing.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/warn-consumed-parsing.cpp?rev=188206&view=auto
> ==============================================================================
> --- cfe/trunk/test/SemaCXX/warn-consumed-parsing.cpp (added)
> +++ cfe/trunk/test/SemaCXX/warn-consumed-parsing.cpp Mon Aug 12 16:20:55 2013
> @@ -0,0 +1,29 @@
> +// RUN: %clang_cc1 -fsyntax-only -verify -Wconsumed -std=c++11 %s
> +
> +#define CONSUMES __attribute__ ((consumes))
> +#define TESTS_UNCONSUMED __attribute__ ((tests_unconsumed))
> +#define CALLABLE_WHEN_UNCONSUMED __attribute__ ((callable_when_unconsumed))
> +
> +class AttrTester0 {
> + void Consumes(void) __attribute__ ((consumes(42))); // expected-error {{attribute takes no arguments}}
> + bool TestsUnconsumed(void) __attribute__ ((tests_unconsumed(42))); // expected-error {{attribute takes no arguments}}
> + void CallableWhenUnconsumed(void)
> + __attribute__ ((callable_when_unconsumed(42))); // expected-error {{attribute takes no arguments}}
> +};
> +
> +int var0 CONSUMES; // expected-warning {{'consumes' attribute only applies to methods}}
> +int var1 TESTS_UNCONSUMED; // expected-warning {{'tests_unconsumed' attribute only applies to methods}}
> +int var2 CALLABLE_WHEN_UNCONSUMED; // expected-warning {{'callable_when_unconsumed' attribute only applies to methods}}
> +
> +void function0(void) CONSUMES; // expected-warning {{'consumes' attribute only applies to methods}}
> +void function1(void) TESTS_UNCONSUMED; // expected-warning {{'tests_unconsumed' attribute only applies to methods}}
> +void function2(void) CALLABLE_WHEN_UNCONSUMED; // expected-warning {{'callable_when_unconsumed' attribute only applies to methods}}
> +
> +class AttrTester1 {
> + void consumes(void) CONSUMES;
> + bool testsUnconsumed(void) TESTS_UNCONSUMED;
> +};
> +
> +class AttrTester2 {
> + void callableWhenUnconsumed(void) CALLABLE_WHEN_UNCONSUMED;
> +};
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
~Aaron
More information about the cfe-commits
mailing list