Index: cfe/trunk/include/clang/Analysis/PathDiagnostic.h =================================================================== --- cfe/trunk/include/clang/Analysis/PathDiagnostic.h +++ cfe/trunk/include/clang/Analysis/PathDiagnostic.h @@ -0,0 +1,868 @@ +//===- PathDiagnostic.h - Path-Specific Diagnostic Handling -----*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the PathDiagnostic-related interfaces. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H +#define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H + +#include "clang/AST/Stmt.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/Optional.h" +#include "llvm/ADT/PointerUnion.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Allocator.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace clang { + +class AnalysisDeclContext; +class BinaryOperator; +class CallEnter; +class CallExitEnd; +class CallExpr; +class ConditionalOperator; +class Decl; +class Expr; +class LocationContext; +class MemberExpr; +class ProgramPoint; +class SourceManager; + +namespace ento { + +//===----------------------------------------------------------------------===// +// High-level interface for handlers of path-sensitive diagnostics. +//===----------------------------------------------------------------------===// + +class PathDiagnostic; + +class PathDiagnosticConsumer { +public: + class PDFileEntry : public llvm::FoldingSetNode { + public: + PDFileEntry(llvm::FoldingSetNodeID &NodeID) : NodeID(NodeID) {} + + using ConsumerFiles = std::vector>; + + /// A vector of pairs. + ConsumerFiles files; + + /// A precomputed hash tag used for uniquing PDFileEntry objects. + const llvm::FoldingSetNodeID NodeID; + + /// Used for profiling in the FoldingSet. + void Profile(llvm::FoldingSetNodeID &ID) { ID = NodeID; } + }; + + class FilesMade { + llvm::BumpPtrAllocator Alloc; + llvm::FoldingSet Set; + + public: + ~FilesMade(); + + bool empty() const { return Set.empty(); } + + void addDiagnostic(const PathDiagnostic &PD, + StringRef ConsumerName, + StringRef fileName); + + PDFileEntry::ConsumerFiles *getFiles(const PathDiagnostic &PD); + }; + +private: + virtual void anchor(); + +public: + PathDiagnosticConsumer() = default; + virtual ~PathDiagnosticConsumer(); + + void FlushDiagnostics(FilesMade *FilesMade); + + virtual void FlushDiagnosticsImpl(std::vector &Diags, + FilesMade *filesMade) = 0; + + virtual StringRef getName() const = 0; + + void HandlePathDiagnostic(std::unique_ptr D); + + enum PathGenerationScheme { + /// Only runs visitors, no output generated. + None, + + /// Used for HTML, SARIF, and text output. + Minimal, + + /// Used for plist output, used for "arrows" generation. + Extensive, + }; + + virtual PathGenerationScheme getGenerationScheme() const { return Minimal; } + + bool shouldGenerateDiagnostics() const { + return getGenerationScheme() != None; + } + + bool shouldAddPathEdges() const { return getGenerationScheme() == Extensive; } + + virtual bool supportsLogicalOpControlFlow() const { return false; } + + /// Return true if the PathDiagnosticConsumer supports individual + /// PathDiagnostics that span multiple files. + virtual bool supportsCrossFileDiagnostics() const { return false; } + +protected: + bool flushed = false; + llvm::FoldingSet Diags; +}; + +//===----------------------------------------------------------------------===// +// Path-sensitive diagnostics. +//===----------------------------------------------------------------------===// + +class PathDiagnosticRange : public SourceRange { +public: + bool isPoint = false; + + PathDiagnosticRange(SourceRange R, bool isP = false) + : SourceRange(R), isPoint(isP) {} + PathDiagnosticRange() = default; +}; + +using LocationOrAnalysisDeclContext = + llvm::PointerUnion; + +class PathDiagnosticLocation { +private: + enum Kind { RangeK, SingleLocK, StmtK, DeclK } K = SingleLocK; + + const Stmt *S = nullptr; + const Decl *D = nullptr; + const SourceManager *SM = nullptr; + FullSourceLoc Loc; + PathDiagnosticRange Range; + + PathDiagnosticLocation(SourceLocation L, const SourceManager &sm, Kind kind) + : K(kind), SM(&sm), Loc(genLocation(L)), Range(genRange()) {} + + FullSourceLoc genLocation( + SourceLocation L = SourceLocation(), + LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const; + + PathDiagnosticRange genRange( + LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const; + +public: + /// Create an invalid location. + PathDiagnosticLocation() = default; + + /// Create a location corresponding to the given statement. + PathDiagnosticLocation(const Stmt *s, const SourceManager &sm, + LocationOrAnalysisDeclContext lac) + : K(s->getBeginLoc().isValid() ? StmtK : SingleLocK), + S(K == StmtK ? s : nullptr), SM(&sm), + Loc(genLocation(SourceLocation(), lac)), Range(genRange(lac)) { + assert(K == SingleLocK || S); + assert(K == SingleLocK || Loc.isValid()); + assert(K == SingleLocK || Range.isValid()); + } + + /// Create a location corresponding to the given declaration. + PathDiagnosticLocation(const Decl *d, const SourceManager &sm) + : K(DeclK), D(d), SM(&sm), Loc(genLocation()), Range(genRange()) { + assert(D); + assert(Loc.isValid()); + assert(Range.isValid()); + } + + /// Create a location at an explicit offset in the source. + /// + /// This should only be used if there are no more appropriate constructors. + PathDiagnosticLocation(SourceLocation loc, const SourceManager &sm) + : SM(&sm), Loc(loc, sm), Range(genRange()) { + assert(Loc.isValid()); + assert(Range.isValid()); + } + + /// Create a location corresponding to the given declaration. + static PathDiagnosticLocation create(const Decl *D, + const SourceManager &SM) { + return PathDiagnosticLocation(D, SM); + } + + /// Create a location for the beginning of the declaration. + static PathDiagnosticLocation createBegin(const Decl *D, + const SourceManager &SM); + + /// Create a location for the beginning of the declaration. + /// The third argument is ignored, useful for generic treatment + /// of statements and declarations. + static PathDiagnosticLocation + createBegin(const Decl *D, const SourceManager &SM, + const LocationOrAnalysisDeclContext LAC) { + return createBegin(D, SM); + } + + /// Create a location for the beginning of the statement. + static PathDiagnosticLocation createBegin(const Stmt *S, + const SourceManager &SM, + const LocationOrAnalysisDeclContext LAC); + + /// Create a location for the end of the statement. + /// + /// If the statement is a CompoundStatement, the location will point to the + /// closing brace instead of following it. + static PathDiagnosticLocation createEnd(const Stmt *S, + const SourceManager &SM, + const LocationOrAnalysisDeclContext LAC); + + /// Create the location for the operator of the binary expression. + /// Assumes the statement has a valid location. + static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO, + const SourceManager &SM); + static PathDiagnosticLocation createConditionalColonLoc( + const ConditionalOperator *CO, + const SourceManager &SM); + + /// For member expressions, return the location of the '.' or '->'. + /// Assumes the statement has a valid location. + static PathDiagnosticLocation createMemberLoc(const MemberExpr *ME, + const SourceManager &SM); + + /// Create a location for the beginning of the compound statement. + /// Assumes the statement has a valid location. + static PathDiagnosticLocation createBeginBrace(const CompoundStmt *CS, + const SourceManager &SM); + + /// Create a location for the end of the compound statement. + /// Assumes the statement has a valid location. + static PathDiagnosticLocation createEndBrace(const CompoundStmt *CS, + const SourceManager &SM); + + /// Create a location for the beginning of the enclosing declaration body. + /// Defaults to the beginning of the first statement in the declaration body. + static PathDiagnosticLocation createDeclBegin(const LocationContext *LC, + const SourceManager &SM); + + /// Constructs a location for the end of the enclosing declaration body. + /// Defaults to the end of brace. + static PathDiagnosticLocation createDeclEnd(const LocationContext *LC, + const SourceManager &SM); + + /// Create a location corresponding to the given valid ProgramPoint. + static PathDiagnosticLocation create(const ProgramPoint &P, + const SourceManager &SMng); + + /// Convert the given location into a single kind location. + static PathDiagnosticLocation createSingleLocation( + const PathDiagnosticLocation &PDL); + + /// Construct a source location that corresponds to either the beginning + /// or the end of the given statement, or a nearby valid source location + /// if the statement does not have a valid source location of its own. + static SourceLocation + getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC, + bool UseEndOfStatement = false); + + bool operator==(const PathDiagnosticLocation &X) const { + return K == X.K && Loc == X.Loc && Range == X.Range; + } + + bool operator!=(const PathDiagnosticLocation &X) const { + return !(*this == X); + } + + bool isValid() const { + return SM != nullptr; + } + + FullSourceLoc asLocation() const { + return Loc; + } + + PathDiagnosticRange asRange() const { + return Range; + } + + const Stmt *asStmt() const { assert(isValid()); return S; } + const Stmt *getStmtOrNull() const { + if (!isValid()) + return nullptr; + return asStmt(); + } + + const Decl *asDecl() const { assert(isValid()); return D; } + + bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; } + + bool hasValidLocation() const { return asLocation().isValid(); } + + void invalidate() { + *this = PathDiagnosticLocation(); + } + + void flatten(); + + const SourceManager& getManager() const { assert(isValid()); return *SM; } + + void Profile(llvm::FoldingSetNodeID &ID) const; + + void dump() const; +}; + +class PathDiagnosticLocationPair { +private: + PathDiagnosticLocation Start, End; + +public: + PathDiagnosticLocationPair(const PathDiagnosticLocation &start, + const PathDiagnosticLocation &end) + : Start(start), End(end) {} + + const PathDiagnosticLocation &getStart() const { return Start; } + const PathDiagnosticLocation &getEnd() const { return End; } + + void setStart(const PathDiagnosticLocation &L) { Start = L; } + void setEnd(const PathDiagnosticLocation &L) { End = L; } + + void flatten() { + Start.flatten(); + End.flatten(); + } + + void Profile(llvm::FoldingSetNodeID &ID) const { + Start.Profile(ID); + End.Profile(ID); + } +}; + +//===----------------------------------------------------------------------===// +// Path "pieces" for path-sensitive diagnostics. +//===----------------------------------------------------------------------===// + +class PathDiagnosticPiece: public llvm::FoldingSetNode { +public: + enum Kind { ControlFlow, Event, Macro, Call, Note, PopUp }; + enum DisplayHint { Above, Below }; + +private: + const std::string str; + const Kind kind; + const DisplayHint Hint; + + /// In the containing bug report, this piece is the last piece from + /// the main source file. + bool LastInMainSourceFile = false; + + /// A constant string that can be used to tag the PathDiagnosticPiece, + /// typically with the identification of the creator. The actual pointer + /// value is meant to be an identifier; the string itself is useful for + /// debugging. + StringRef Tag; + + std::vector ranges; + std::vector fixits; + +protected: + PathDiagnosticPiece(StringRef s, Kind k, DisplayHint hint = Below); + PathDiagnosticPiece(Kind k, DisplayHint hint = Below); + +public: + PathDiagnosticPiece() = delete; + PathDiagnosticPiece(const PathDiagnosticPiece &) = delete; + PathDiagnosticPiece &operator=(const PathDiagnosticPiece &) = delete; + virtual ~PathDiagnosticPiece(); + + StringRef getString() const { return str; } + + /// Tag this PathDiagnosticPiece with the given C-string. + void setTag(const char *tag) { Tag = tag; } + + /// Return the opaque tag (if any) on the PathDiagnosticPiece. + const void *getTag() const { return Tag.data(); } + + /// Return the string representation of the tag. This is useful + /// for debugging. + StringRef getTagStr() const { return Tag; } + + /// getDisplayHint - Return a hint indicating where the diagnostic should + /// be displayed by the PathDiagnosticConsumer. + DisplayHint getDisplayHint() const { return Hint; } + + virtual PathDiagnosticLocation getLocation() const = 0; + virtual void flattenLocations() = 0; + + Kind getKind() const { return kind; } + + void addRange(SourceRange R) { + if (!R.isValid()) + return; + ranges.push_back(R); + } + + void addRange(SourceLocation B, SourceLocation E) { + if (!B.isValid() || !E.isValid()) + return; + ranges.push_back(SourceRange(B,E)); + } + + void addFixit(FixItHint F) { + fixits.push_back(F); + } + + /// Return the SourceRanges associated with this PathDiagnosticPiece. + ArrayRef getRanges() const { return ranges; } + + /// Return the fix-it hints associated with this PathDiagnosticPiece. + ArrayRef getFixits() const { return fixits; } + + virtual void Profile(llvm::FoldingSetNodeID &ID) const; + + void setAsLastInMainSourceFile() { + LastInMainSourceFile = true; + } + + bool isLastInMainSourceFile() const { + return LastInMainSourceFile; + } + + virtual void dump() const = 0; +}; + +using PathDiagnosticPieceRef = std::shared_ptr; + +class PathPieces : public std::list { + void flattenTo(PathPieces &Primary, PathPieces &Current, + bool ShouldFlattenMacros) const; + +public: + PathPieces flatten(bool ShouldFlattenMacros) const { + PathPieces Result; + flattenTo(Result, Result, ShouldFlattenMacros); + return Result; + } + + void dump() const; +}; + +class PathDiagnosticSpotPiece : public PathDiagnosticPiece { +private: + PathDiagnosticLocation Pos; + +public: + PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos, + StringRef s, + PathDiagnosticPiece::Kind k, + bool addPosRange = true) + : PathDiagnosticPiece(s, k), Pos(pos) { + assert(Pos.isValid() && Pos.hasValidLocation() && + "PathDiagnosticSpotPiece's must have a valid location."); + if (addPosRange && Pos.hasRange()) addRange(Pos.asRange()); + } + + PathDiagnosticLocation getLocation() const override { return Pos; } + void flattenLocations() override { Pos.flatten(); } + + void Profile(llvm::FoldingSetNodeID &ID) const override; + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == Event || P->getKind() == Macro || + P->getKind() == Note || P->getKind() == PopUp; + } +}; + +class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece { + Optional IsPrunable; + +public: + PathDiagnosticEventPiece(const PathDiagnosticLocation &pos, + StringRef s, bool addPosRange = true) + : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {} + ~PathDiagnosticEventPiece() override; + + /// Mark the diagnostic piece as being potentially prunable. This + /// flag may have been previously set, at which point it will not + /// be reset unless one specifies to do so. + void setPrunable(bool isPrunable, bool override = false) { + if (IsPrunable.hasValue() && !override) + return; + IsPrunable = isPrunable; + } + + /// Return true if the diagnostic piece is prunable. + bool isPrunable() const { + return IsPrunable.hasValue() ? IsPrunable.getValue() : false; + } + + void dump() const override; + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == Event; + } +}; + +class PathDiagnosticCallPiece : public PathDiagnosticPiece { + const Decl *Caller; + const Decl *Callee = nullptr; + + // Flag signifying that this diagnostic has only call enter and no matching + // call exit. + bool NoExit; + + // Flag signifying that the callee function is an Objective-C autosynthesized + // property getter or setter. + bool IsCalleeAnAutosynthesizedPropertyAccessor = false; + + // The custom string, which should appear after the call Return Diagnostic. + // TODO: Should we allow multiple diagnostics? + std::string CallStackMessage; + + PathDiagnosticCallPiece(const Decl *callerD, + const PathDiagnosticLocation &callReturnPos) + : PathDiagnosticPiece(Call), Caller(callerD), NoExit(false), + callReturn(callReturnPos) {} + PathDiagnosticCallPiece(PathPieces &oldPath, const Decl *caller) + : PathDiagnosticPiece(Call), Caller(caller), NoExit(true), + path(oldPath) {} + +public: + PathDiagnosticLocation callEnter; + PathDiagnosticLocation callEnterWithin; + PathDiagnosticLocation callReturn; + PathPieces path; + + ~PathDiagnosticCallPiece() override; + + const Decl *getCaller() const { return Caller; } + + const Decl *getCallee() const { return Callee; } + void setCallee(const CallEnter &CE, const SourceManager &SM); + + bool hasCallStackMessage() { return !CallStackMessage.empty(); } + void setCallStackMessage(StringRef st) { CallStackMessage = st; } + + PathDiagnosticLocation getLocation() const override { return callEnter; } + + std::shared_ptr getCallEnterEvent() const; + std::shared_ptr + getCallEnterWithinCallerEvent() const; + std::shared_ptr getCallExitEvent() const; + + void flattenLocations() override { + callEnter.flatten(); + callReturn.flatten(); + for (const auto &I : path) + I->flattenLocations(); + } + + static std::shared_ptr + construct(const CallExitEnd &CE, + const SourceManager &SM); + + static PathDiagnosticCallPiece *construct(PathPieces &pieces, + const Decl *caller); + + void dump() const override; + + void Profile(llvm::FoldingSetNodeID &ID) const override; + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == Call; + } +}; + +class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece { + std::vector LPairs; + +public: + PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, + const PathDiagnosticLocation &endPos, + StringRef s) + : PathDiagnosticPiece(s, ControlFlow) { + LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); + } + + PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, + const PathDiagnosticLocation &endPos) + : PathDiagnosticPiece(ControlFlow) { + LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); + } + + ~PathDiagnosticControlFlowPiece() override; + + PathDiagnosticLocation getStartLocation() const { + assert(!LPairs.empty() && + "PathDiagnosticControlFlowPiece needs at least one location."); + return LPairs[0].getStart(); + } + + PathDiagnosticLocation getEndLocation() const { + assert(!LPairs.empty() && + "PathDiagnosticControlFlowPiece needs at least one location."); + return LPairs[0].getEnd(); + } + + void setStartLocation(const PathDiagnosticLocation &L) { + LPairs[0].setStart(L); + } + + void setEndLocation(const PathDiagnosticLocation &L) { + LPairs[0].setEnd(L); + } + + void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); } + + PathDiagnosticLocation getLocation() const override { + return getStartLocation(); + } + + using iterator = std::vector::iterator; + + iterator begin() { return LPairs.begin(); } + iterator end() { return LPairs.end(); } + + void flattenLocations() override { + for (auto &I : *this) + I.flatten(); + } + + using const_iterator = + std::vector::const_iterator; + + const_iterator begin() const { return LPairs.begin(); } + const_iterator end() const { return LPairs.end(); } + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == ControlFlow; + } + + void dump() const override; + + void Profile(llvm::FoldingSetNodeID &ID) const override; +}; + +class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece { +public: + PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos) + : PathDiagnosticSpotPiece(pos, "", Macro) {} + ~PathDiagnosticMacroPiece() override; + + PathPieces subPieces; + + void flattenLocations() override { + PathDiagnosticSpotPiece::flattenLocations(); + for (const auto &I : subPieces) + I->flattenLocations(); + } + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == Macro; + } + + void dump() const override; + + void Profile(llvm::FoldingSetNodeID &ID) const override; +}; + +class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece { +public: + PathDiagnosticNotePiece(const PathDiagnosticLocation &Pos, StringRef S, + bool AddPosRange = true) + : PathDiagnosticSpotPiece(Pos, S, Note, AddPosRange) {} + ~PathDiagnosticNotePiece() override; + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == Note; + } + + void dump() const override; + + void Profile(llvm::FoldingSetNodeID &ID) const override; +}; + +class PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece { +public: + PathDiagnosticPopUpPiece(const PathDiagnosticLocation &Pos, StringRef S, + bool AddPosRange = true) + : PathDiagnosticSpotPiece(Pos, S, PopUp, AddPosRange) {} + ~PathDiagnosticPopUpPiece() override; + + static bool classof(const PathDiagnosticPiece *P) { + return P->getKind() == PopUp; + } + + void dump() const override; + + void Profile(llvm::FoldingSetNodeID &ID) const override; +}; + +/// File IDs mapped to sets of line numbers. +using FilesToLineNumsMap = std::map>; + +/// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive +/// diagnostic. It represents an ordered-collection of PathDiagnosticPieces, +/// each which represent the pieces of the path. +class PathDiagnostic : public llvm::FoldingSetNode { + std::string CheckName; + const Decl *DeclWithIssue; + std::string BugType; + std::string VerboseDesc; + std::string ShortDesc; + std::string Category; + std::deque OtherDesc; + + /// Loc The location of the path diagnostic report. + PathDiagnosticLocation Loc; + + PathPieces pathImpl; + SmallVector pathStack; + + /// Important bug uniqueing location. + /// The location info is useful to differentiate between bugs. + PathDiagnosticLocation UniqueingLoc; + const Decl *UniqueingDecl; + + /// Lines executed in the path. + std::unique_ptr ExecutedLines; + +public: + PathDiagnostic() = delete; + PathDiagnostic(StringRef CheckName, const Decl *DeclWithIssue, + StringRef bugtype, StringRef verboseDesc, StringRef shortDesc, + StringRef category, PathDiagnosticLocation LocationToUnique, + const Decl *DeclToUnique, + std::unique_ptr ExecutedLines); + ~PathDiagnostic(); + + const PathPieces &path; + + /// Return the path currently used by builders for constructing the + /// PathDiagnostic. + PathPieces &getActivePath() { + if (pathStack.empty()) + return pathImpl; + return *pathStack.back(); + } + + /// Return a mutable version of 'path'. + PathPieces &getMutablePieces() { + return pathImpl; + } + + /// Return the unrolled size of the path. + unsigned full_size(); + + void pushActivePath(PathPieces *p) { pathStack.push_back(p); } + void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); } + + bool isWithinCall() const { return !pathStack.empty(); } + + void setEndOfPath(PathDiagnosticPieceRef EndPiece) { + assert(!Loc.isValid() && "End location already set!"); + Loc = EndPiece->getLocation(); + assert(Loc.isValid() && "Invalid location for end-of-path piece"); + getActivePath().push_back(std::move(EndPiece)); + } + + void appendToDesc(StringRef S) { + if (!ShortDesc.empty()) + ShortDesc += S; + VerboseDesc += S; + } + + StringRef getVerboseDescription() const { return VerboseDesc; } + + StringRef getShortDescription() const { + return ShortDesc.empty() ? VerboseDesc : ShortDesc; + } + + StringRef getCheckName() const { return CheckName; } + StringRef getBugType() const { return BugType; } + StringRef getCategory() const { return Category; } + + using meta_iterator = std::deque::const_iterator; + + meta_iterator meta_begin() const { return OtherDesc.begin(); } + meta_iterator meta_end() const { return OtherDesc.end(); } + void addMeta(StringRef s) { OtherDesc.push_back(s); } + + const FilesToLineNumsMap &getExecutedLines() const { + return *ExecutedLines; + } + + FilesToLineNumsMap &getExecutedLines() { + return *ExecutedLines; + } + + /// Return the semantic context where an issue occurred. If the + /// issue occurs along a path, this represents the "central" area + /// where the bug manifests. + const Decl *getDeclWithIssue() const { return DeclWithIssue; } + + void setDeclWithIssue(const Decl *D) { + DeclWithIssue = D; + } + + PathDiagnosticLocation getLocation() const { + return Loc; + } + + void setLocation(PathDiagnosticLocation NewLoc) { + Loc = NewLoc; + } + + /// Get the location on which the report should be uniqued. + PathDiagnosticLocation getUniqueingLoc() const { + return UniqueingLoc; + } + + /// Get the declaration containing the uniqueing location. + const Decl *getUniqueingDecl() const { + return UniqueingDecl; + } + + void flattenLocations() { + Loc.flatten(); + for (const auto &I : pathImpl) + I->flattenLocations(); + } + + /// Profiles the diagnostic, independent of the path it references. + /// + /// This can be used to merge diagnostics that refer to the same issue + /// along different paths. + void Profile(llvm::FoldingSetNodeID &ID) const; + + /// Profiles the diagnostic, including its path. + /// + /// Two diagnostics with the same issue along different paths will generate + /// different profiles. + void FullProfile(llvm::FoldingSetNodeID &ID) const; +}; + +} // namespace ento +} // namespace clang + +#endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H Index: cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h =================================================================== --- cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h +++ cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h @@ -14,10 +14,10 @@ #ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H #define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_BUGREPORTER_H +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" Index: cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h =================================================================== --- cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h +++ cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h @@ -1,868 +0,0 @@ -//===- PathDiagnostic.h - Path-Specific Diagnostic Handling -----*- C++ -*-===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the PathDiagnostic-related interfaces. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H -#define LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H - -#include "clang/AST/Stmt.h" -#include "clang/Analysis/AnalysisDeclContext.h" -#include "clang/Basic/LLVM.h" -#include "clang/Basic/SourceLocation.h" -#include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/FoldingSet.h" -#include "llvm/ADT/Optional.h" -#include "llvm/ADT/PointerUnion.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/Allocator.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace clang { - -class AnalysisDeclContext; -class BinaryOperator; -class CallEnter; -class CallExitEnd; -class CallExpr; -class ConditionalOperator; -class Decl; -class Expr; -class LocationContext; -class MemberExpr; -class ProgramPoint; -class SourceManager; - -namespace ento { - -//===----------------------------------------------------------------------===// -// High-level interface for handlers of path-sensitive diagnostics. -//===----------------------------------------------------------------------===// - -class PathDiagnostic; - -class PathDiagnosticConsumer { -public: - class PDFileEntry : public llvm::FoldingSetNode { - public: - PDFileEntry(llvm::FoldingSetNodeID &NodeID) : NodeID(NodeID) {} - - using ConsumerFiles = std::vector>; - - /// A vector of pairs. - ConsumerFiles files; - - /// A precomputed hash tag used for uniquing PDFileEntry objects. - const llvm::FoldingSetNodeID NodeID; - - /// Used for profiling in the FoldingSet. - void Profile(llvm::FoldingSetNodeID &ID) { ID = NodeID; } - }; - - class FilesMade { - llvm::BumpPtrAllocator Alloc; - llvm::FoldingSet Set; - - public: - ~FilesMade(); - - bool empty() const { return Set.empty(); } - - void addDiagnostic(const PathDiagnostic &PD, - StringRef ConsumerName, - StringRef fileName); - - PDFileEntry::ConsumerFiles *getFiles(const PathDiagnostic &PD); - }; - -private: - virtual void anchor(); - -public: - PathDiagnosticConsumer() = default; - virtual ~PathDiagnosticConsumer(); - - void FlushDiagnostics(FilesMade *FilesMade); - - virtual void FlushDiagnosticsImpl(std::vector &Diags, - FilesMade *filesMade) = 0; - - virtual StringRef getName() const = 0; - - void HandlePathDiagnostic(std::unique_ptr D); - - enum PathGenerationScheme { - /// Only runs visitors, no output generated. - None, - - /// Used for HTML, SARIF, and text output. - Minimal, - - /// Used for plist output, used for "arrows" generation. - Extensive, - }; - - virtual PathGenerationScheme getGenerationScheme() const { return Minimal; } - - bool shouldGenerateDiagnostics() const { - return getGenerationScheme() != None; - } - - bool shouldAddPathEdges() const { return getGenerationScheme() == Extensive; } - - virtual bool supportsLogicalOpControlFlow() const { return false; } - - /// Return true if the PathDiagnosticConsumer supports individual - /// PathDiagnostics that span multiple files. - virtual bool supportsCrossFileDiagnostics() const { return false; } - -protected: - bool flushed = false; - llvm::FoldingSet Diags; -}; - -//===----------------------------------------------------------------------===// -// Path-sensitive diagnostics. -//===----------------------------------------------------------------------===// - -class PathDiagnosticRange : public SourceRange { -public: - bool isPoint = false; - - PathDiagnosticRange(SourceRange R, bool isP = false) - : SourceRange(R), isPoint(isP) {} - PathDiagnosticRange() = default; -}; - -using LocationOrAnalysisDeclContext = - llvm::PointerUnion; - -class PathDiagnosticLocation { -private: - enum Kind { RangeK, SingleLocK, StmtK, DeclK } K = SingleLocK; - - const Stmt *S = nullptr; - const Decl *D = nullptr; - const SourceManager *SM = nullptr; - FullSourceLoc Loc; - PathDiagnosticRange Range; - - PathDiagnosticLocation(SourceLocation L, const SourceManager &sm, Kind kind) - : K(kind), SM(&sm), Loc(genLocation(L)), Range(genRange()) {} - - FullSourceLoc genLocation( - SourceLocation L = SourceLocation(), - LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const; - - PathDiagnosticRange genRange( - LocationOrAnalysisDeclContext LAC = (AnalysisDeclContext *)nullptr) const; - -public: - /// Create an invalid location. - PathDiagnosticLocation() = default; - - /// Create a location corresponding to the given statement. - PathDiagnosticLocation(const Stmt *s, const SourceManager &sm, - LocationOrAnalysisDeclContext lac) - : K(s->getBeginLoc().isValid() ? StmtK : SingleLocK), - S(K == StmtK ? s : nullptr), SM(&sm), - Loc(genLocation(SourceLocation(), lac)), Range(genRange(lac)) { - assert(K == SingleLocK || S); - assert(K == SingleLocK || Loc.isValid()); - assert(K == SingleLocK || Range.isValid()); - } - - /// Create a location corresponding to the given declaration. - PathDiagnosticLocation(const Decl *d, const SourceManager &sm) - : K(DeclK), D(d), SM(&sm), Loc(genLocation()), Range(genRange()) { - assert(D); - assert(Loc.isValid()); - assert(Range.isValid()); - } - - /// Create a location at an explicit offset in the source. - /// - /// This should only be used if there are no more appropriate constructors. - PathDiagnosticLocation(SourceLocation loc, const SourceManager &sm) - : SM(&sm), Loc(loc, sm), Range(genRange()) { - assert(Loc.isValid()); - assert(Range.isValid()); - } - - /// Create a location corresponding to the given declaration. - static PathDiagnosticLocation create(const Decl *D, - const SourceManager &SM) { - return PathDiagnosticLocation(D, SM); - } - - /// Create a location for the beginning of the declaration. - static PathDiagnosticLocation createBegin(const Decl *D, - const SourceManager &SM); - - /// Create a location for the beginning of the declaration. - /// The third argument is ignored, useful for generic treatment - /// of statements and declarations. - static PathDiagnosticLocation - createBegin(const Decl *D, const SourceManager &SM, - const LocationOrAnalysisDeclContext LAC) { - return createBegin(D, SM); - } - - /// Create a location for the beginning of the statement. - static PathDiagnosticLocation createBegin(const Stmt *S, - const SourceManager &SM, - const LocationOrAnalysisDeclContext LAC); - - /// Create a location for the end of the statement. - /// - /// If the statement is a CompoundStatement, the location will point to the - /// closing brace instead of following it. - static PathDiagnosticLocation createEnd(const Stmt *S, - const SourceManager &SM, - const LocationOrAnalysisDeclContext LAC); - - /// Create the location for the operator of the binary expression. - /// Assumes the statement has a valid location. - static PathDiagnosticLocation createOperatorLoc(const BinaryOperator *BO, - const SourceManager &SM); - static PathDiagnosticLocation createConditionalColonLoc( - const ConditionalOperator *CO, - const SourceManager &SM); - - /// For member expressions, return the location of the '.' or '->'. - /// Assumes the statement has a valid location. - static PathDiagnosticLocation createMemberLoc(const MemberExpr *ME, - const SourceManager &SM); - - /// Create a location for the beginning of the compound statement. - /// Assumes the statement has a valid location. - static PathDiagnosticLocation createBeginBrace(const CompoundStmt *CS, - const SourceManager &SM); - - /// Create a location for the end of the compound statement. - /// Assumes the statement has a valid location. - static PathDiagnosticLocation createEndBrace(const CompoundStmt *CS, - const SourceManager &SM); - - /// Create a location for the beginning of the enclosing declaration body. - /// Defaults to the beginning of the first statement in the declaration body. - static PathDiagnosticLocation createDeclBegin(const LocationContext *LC, - const SourceManager &SM); - - /// Constructs a location for the end of the enclosing declaration body. - /// Defaults to the end of brace. - static PathDiagnosticLocation createDeclEnd(const LocationContext *LC, - const SourceManager &SM); - - /// Create a location corresponding to the given valid ProgramPoint. - static PathDiagnosticLocation create(const ProgramPoint &P, - const SourceManager &SMng); - - /// Convert the given location into a single kind location. - static PathDiagnosticLocation createSingleLocation( - const PathDiagnosticLocation &PDL); - - /// Construct a source location that corresponds to either the beginning - /// or the end of the given statement, or a nearby valid source location - /// if the statement does not have a valid source location of its own. - static SourceLocation - getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC, - bool UseEndOfStatement = false); - - bool operator==(const PathDiagnosticLocation &X) const { - return K == X.K && Loc == X.Loc && Range == X.Range; - } - - bool operator!=(const PathDiagnosticLocation &X) const { - return !(*this == X); - } - - bool isValid() const { - return SM != nullptr; - } - - FullSourceLoc asLocation() const { - return Loc; - } - - PathDiagnosticRange asRange() const { - return Range; - } - - const Stmt *asStmt() const { assert(isValid()); return S; } - const Stmt *getStmtOrNull() const { - if (!isValid()) - return nullptr; - return asStmt(); - } - - const Decl *asDecl() const { assert(isValid()); return D; } - - bool hasRange() const { return K == StmtK || K == RangeK || K == DeclK; } - - bool hasValidLocation() const { return asLocation().isValid(); } - - void invalidate() { - *this = PathDiagnosticLocation(); - } - - void flatten(); - - const SourceManager& getManager() const { assert(isValid()); return *SM; } - - void Profile(llvm::FoldingSetNodeID &ID) const; - - void dump() const; -}; - -class PathDiagnosticLocationPair { -private: - PathDiagnosticLocation Start, End; - -public: - PathDiagnosticLocationPair(const PathDiagnosticLocation &start, - const PathDiagnosticLocation &end) - : Start(start), End(end) {} - - const PathDiagnosticLocation &getStart() const { return Start; } - const PathDiagnosticLocation &getEnd() const { return End; } - - void setStart(const PathDiagnosticLocation &L) { Start = L; } - void setEnd(const PathDiagnosticLocation &L) { End = L; } - - void flatten() { - Start.flatten(); - End.flatten(); - } - - void Profile(llvm::FoldingSetNodeID &ID) const { - Start.Profile(ID); - End.Profile(ID); - } -}; - -//===----------------------------------------------------------------------===// -// Path "pieces" for path-sensitive diagnostics. -//===----------------------------------------------------------------------===// - -class PathDiagnosticPiece: public llvm::FoldingSetNode { -public: - enum Kind { ControlFlow, Event, Macro, Call, Note, PopUp }; - enum DisplayHint { Above, Below }; - -private: - const std::string str; - const Kind kind; - const DisplayHint Hint; - - /// In the containing bug report, this piece is the last piece from - /// the main source file. - bool LastInMainSourceFile = false; - - /// A constant string that can be used to tag the PathDiagnosticPiece, - /// typically with the identification of the creator. The actual pointer - /// value is meant to be an identifier; the string itself is useful for - /// debugging. - StringRef Tag; - - std::vector ranges; - std::vector fixits; - -protected: - PathDiagnosticPiece(StringRef s, Kind k, DisplayHint hint = Below); - PathDiagnosticPiece(Kind k, DisplayHint hint = Below); - -public: - PathDiagnosticPiece() = delete; - PathDiagnosticPiece(const PathDiagnosticPiece &) = delete; - PathDiagnosticPiece &operator=(const PathDiagnosticPiece &) = delete; - virtual ~PathDiagnosticPiece(); - - StringRef getString() const { return str; } - - /// Tag this PathDiagnosticPiece with the given C-string. - void setTag(const char *tag) { Tag = tag; } - - /// Return the opaque tag (if any) on the PathDiagnosticPiece. - const void *getTag() const { return Tag.data(); } - - /// Return the string representation of the tag. This is useful - /// for debugging. - StringRef getTagStr() const { return Tag; } - - /// getDisplayHint - Return a hint indicating where the diagnostic should - /// be displayed by the PathDiagnosticConsumer. - DisplayHint getDisplayHint() const { return Hint; } - - virtual PathDiagnosticLocation getLocation() const = 0; - virtual void flattenLocations() = 0; - - Kind getKind() const { return kind; } - - void addRange(SourceRange R) { - if (!R.isValid()) - return; - ranges.push_back(R); - } - - void addRange(SourceLocation B, SourceLocation E) { - if (!B.isValid() || !E.isValid()) - return; - ranges.push_back(SourceRange(B,E)); - } - - void addFixit(FixItHint F) { - fixits.push_back(F); - } - - /// Return the SourceRanges associated with this PathDiagnosticPiece. - ArrayRef getRanges() const { return ranges; } - - /// Return the fix-it hints associated with this PathDiagnosticPiece. - ArrayRef getFixits() const { return fixits; } - - virtual void Profile(llvm::FoldingSetNodeID &ID) const; - - void setAsLastInMainSourceFile() { - LastInMainSourceFile = true; - } - - bool isLastInMainSourceFile() const { - return LastInMainSourceFile; - } - - virtual void dump() const = 0; -}; - -using PathDiagnosticPieceRef = std::shared_ptr; - -class PathPieces : public std::list { - void flattenTo(PathPieces &Primary, PathPieces &Current, - bool ShouldFlattenMacros) const; - -public: - PathPieces flatten(bool ShouldFlattenMacros) const { - PathPieces Result; - flattenTo(Result, Result, ShouldFlattenMacros); - return Result; - } - - void dump() const; -}; - -class PathDiagnosticSpotPiece : public PathDiagnosticPiece { -private: - PathDiagnosticLocation Pos; - -public: - PathDiagnosticSpotPiece(const PathDiagnosticLocation &pos, - StringRef s, - PathDiagnosticPiece::Kind k, - bool addPosRange = true) - : PathDiagnosticPiece(s, k), Pos(pos) { - assert(Pos.isValid() && Pos.hasValidLocation() && - "PathDiagnosticSpotPiece's must have a valid location."); - if (addPosRange && Pos.hasRange()) addRange(Pos.asRange()); - } - - PathDiagnosticLocation getLocation() const override { return Pos; } - void flattenLocations() override { Pos.flatten(); } - - void Profile(llvm::FoldingSetNodeID &ID) const override; - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == Event || P->getKind() == Macro || - P->getKind() == Note || P->getKind() == PopUp; - } -}; - -class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece { - Optional IsPrunable; - -public: - PathDiagnosticEventPiece(const PathDiagnosticLocation &pos, - StringRef s, bool addPosRange = true) - : PathDiagnosticSpotPiece(pos, s, Event, addPosRange) {} - ~PathDiagnosticEventPiece() override; - - /// Mark the diagnostic piece as being potentially prunable. This - /// flag may have been previously set, at which point it will not - /// be reset unless one specifies to do so. - void setPrunable(bool isPrunable, bool override = false) { - if (IsPrunable.hasValue() && !override) - return; - IsPrunable = isPrunable; - } - - /// Return true if the diagnostic piece is prunable. - bool isPrunable() const { - return IsPrunable.hasValue() ? IsPrunable.getValue() : false; - } - - void dump() const override; - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == Event; - } -}; - -class PathDiagnosticCallPiece : public PathDiagnosticPiece { - const Decl *Caller; - const Decl *Callee = nullptr; - - // Flag signifying that this diagnostic has only call enter and no matching - // call exit. - bool NoExit; - - // Flag signifying that the callee function is an Objective-C autosynthesized - // property getter or setter. - bool IsCalleeAnAutosynthesizedPropertyAccessor = false; - - // The custom string, which should appear after the call Return Diagnostic. - // TODO: Should we allow multiple diagnostics? - std::string CallStackMessage; - - PathDiagnosticCallPiece(const Decl *callerD, - const PathDiagnosticLocation &callReturnPos) - : PathDiagnosticPiece(Call), Caller(callerD), NoExit(false), - callReturn(callReturnPos) {} - PathDiagnosticCallPiece(PathPieces &oldPath, const Decl *caller) - : PathDiagnosticPiece(Call), Caller(caller), NoExit(true), - path(oldPath) {} - -public: - PathDiagnosticLocation callEnter; - PathDiagnosticLocation callEnterWithin; - PathDiagnosticLocation callReturn; - PathPieces path; - - ~PathDiagnosticCallPiece() override; - - const Decl *getCaller() const { return Caller; } - - const Decl *getCallee() const { return Callee; } - void setCallee(const CallEnter &CE, const SourceManager &SM); - - bool hasCallStackMessage() { return !CallStackMessage.empty(); } - void setCallStackMessage(StringRef st) { CallStackMessage = st; } - - PathDiagnosticLocation getLocation() const override { return callEnter; } - - std::shared_ptr getCallEnterEvent() const; - std::shared_ptr - getCallEnterWithinCallerEvent() const; - std::shared_ptr getCallExitEvent() const; - - void flattenLocations() override { - callEnter.flatten(); - callReturn.flatten(); - for (const auto &I : path) - I->flattenLocations(); - } - - static std::shared_ptr - construct(const CallExitEnd &CE, - const SourceManager &SM); - - static PathDiagnosticCallPiece *construct(PathPieces &pieces, - const Decl *caller); - - void dump() const override; - - void Profile(llvm::FoldingSetNodeID &ID) const override; - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == Call; - } -}; - -class PathDiagnosticControlFlowPiece : public PathDiagnosticPiece { - std::vector LPairs; - -public: - PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, - const PathDiagnosticLocation &endPos, - StringRef s) - : PathDiagnosticPiece(s, ControlFlow) { - LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); - } - - PathDiagnosticControlFlowPiece(const PathDiagnosticLocation &startPos, - const PathDiagnosticLocation &endPos) - : PathDiagnosticPiece(ControlFlow) { - LPairs.push_back(PathDiagnosticLocationPair(startPos, endPos)); - } - - ~PathDiagnosticControlFlowPiece() override; - - PathDiagnosticLocation getStartLocation() const { - assert(!LPairs.empty() && - "PathDiagnosticControlFlowPiece needs at least one location."); - return LPairs[0].getStart(); - } - - PathDiagnosticLocation getEndLocation() const { - assert(!LPairs.empty() && - "PathDiagnosticControlFlowPiece needs at least one location."); - return LPairs[0].getEnd(); - } - - void setStartLocation(const PathDiagnosticLocation &L) { - LPairs[0].setStart(L); - } - - void setEndLocation(const PathDiagnosticLocation &L) { - LPairs[0].setEnd(L); - } - - void push_back(const PathDiagnosticLocationPair &X) { LPairs.push_back(X); } - - PathDiagnosticLocation getLocation() const override { - return getStartLocation(); - } - - using iterator = std::vector::iterator; - - iterator begin() { return LPairs.begin(); } - iterator end() { return LPairs.end(); } - - void flattenLocations() override { - for (auto &I : *this) - I.flatten(); - } - - using const_iterator = - std::vector::const_iterator; - - const_iterator begin() const { return LPairs.begin(); } - const_iterator end() const { return LPairs.end(); } - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == ControlFlow; - } - - void dump() const override; - - void Profile(llvm::FoldingSetNodeID &ID) const override; -}; - -class PathDiagnosticMacroPiece : public PathDiagnosticSpotPiece { -public: - PathDiagnosticMacroPiece(const PathDiagnosticLocation &pos) - : PathDiagnosticSpotPiece(pos, "", Macro) {} - ~PathDiagnosticMacroPiece() override; - - PathPieces subPieces; - - void flattenLocations() override { - PathDiagnosticSpotPiece::flattenLocations(); - for (const auto &I : subPieces) - I->flattenLocations(); - } - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == Macro; - } - - void dump() const override; - - void Profile(llvm::FoldingSetNodeID &ID) const override; -}; - -class PathDiagnosticNotePiece: public PathDiagnosticSpotPiece { -public: - PathDiagnosticNotePiece(const PathDiagnosticLocation &Pos, StringRef S, - bool AddPosRange = true) - : PathDiagnosticSpotPiece(Pos, S, Note, AddPosRange) {} - ~PathDiagnosticNotePiece() override; - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == Note; - } - - void dump() const override; - - void Profile(llvm::FoldingSetNodeID &ID) const override; -}; - -class PathDiagnosticPopUpPiece: public PathDiagnosticSpotPiece { -public: - PathDiagnosticPopUpPiece(const PathDiagnosticLocation &Pos, StringRef S, - bool AddPosRange = true) - : PathDiagnosticSpotPiece(Pos, S, PopUp, AddPosRange) {} - ~PathDiagnosticPopUpPiece() override; - - static bool classof(const PathDiagnosticPiece *P) { - return P->getKind() == PopUp; - } - - void dump() const override; - - void Profile(llvm::FoldingSetNodeID &ID) const override; -}; - -/// File IDs mapped to sets of line numbers. -using FilesToLineNumsMap = std::map>; - -/// PathDiagnostic - PathDiagnostic objects represent a single path-sensitive -/// diagnostic. It represents an ordered-collection of PathDiagnosticPieces, -/// each which represent the pieces of the path. -class PathDiagnostic : public llvm::FoldingSetNode { - std::string CheckName; - const Decl *DeclWithIssue; - std::string BugType; - std::string VerboseDesc; - std::string ShortDesc; - std::string Category; - std::deque OtherDesc; - - /// Loc The location of the path diagnostic report. - PathDiagnosticLocation Loc; - - PathPieces pathImpl; - SmallVector pathStack; - - /// Important bug uniqueing location. - /// The location info is useful to differentiate between bugs. - PathDiagnosticLocation UniqueingLoc; - const Decl *UniqueingDecl; - - /// Lines executed in the path. - std::unique_ptr ExecutedLines; - -public: - PathDiagnostic() = delete; - PathDiagnostic(StringRef CheckName, const Decl *DeclWithIssue, - StringRef bugtype, StringRef verboseDesc, StringRef shortDesc, - StringRef category, PathDiagnosticLocation LocationToUnique, - const Decl *DeclToUnique, - std::unique_ptr ExecutedLines); - ~PathDiagnostic(); - - const PathPieces &path; - - /// Return the path currently used by builders for constructing the - /// PathDiagnostic. - PathPieces &getActivePath() { - if (pathStack.empty()) - return pathImpl; - return *pathStack.back(); - } - - /// Return a mutable version of 'path'. - PathPieces &getMutablePieces() { - return pathImpl; - } - - /// Return the unrolled size of the path. - unsigned full_size(); - - void pushActivePath(PathPieces *p) { pathStack.push_back(p); } - void popActivePath() { if (!pathStack.empty()) pathStack.pop_back(); } - - bool isWithinCall() const { return !pathStack.empty(); } - - void setEndOfPath(PathDiagnosticPieceRef EndPiece) { - assert(!Loc.isValid() && "End location already set!"); - Loc = EndPiece->getLocation(); - assert(Loc.isValid() && "Invalid location for end-of-path piece"); - getActivePath().push_back(std::move(EndPiece)); - } - - void appendToDesc(StringRef S) { - if (!ShortDesc.empty()) - ShortDesc += S; - VerboseDesc += S; - } - - StringRef getVerboseDescription() const { return VerboseDesc; } - - StringRef getShortDescription() const { - return ShortDesc.empty() ? VerboseDesc : ShortDesc; - } - - StringRef getCheckName() const { return CheckName; } - StringRef getBugType() const { return BugType; } - StringRef getCategory() const { return Category; } - - using meta_iterator = std::deque::const_iterator; - - meta_iterator meta_begin() const { return OtherDesc.begin(); } - meta_iterator meta_end() const { return OtherDesc.end(); } - void addMeta(StringRef s) { OtherDesc.push_back(s); } - - const FilesToLineNumsMap &getExecutedLines() const { - return *ExecutedLines; - } - - FilesToLineNumsMap &getExecutedLines() { - return *ExecutedLines; - } - - /// Return the semantic context where an issue occurred. If the - /// issue occurs along a path, this represents the "central" area - /// where the bug manifests. - const Decl *getDeclWithIssue() const { return DeclWithIssue; } - - void setDeclWithIssue(const Decl *D) { - DeclWithIssue = D; - } - - PathDiagnosticLocation getLocation() const { - return Loc; - } - - void setLocation(PathDiagnosticLocation NewLoc) { - Loc = NewLoc; - } - - /// Get the location on which the report should be uniqued. - PathDiagnosticLocation getUniqueingLoc() const { - return UniqueingLoc; - } - - /// Get the declaration containing the uniqueing location. - const Decl *getUniqueingDecl() const { - return UniqueingDecl; - } - - void flattenLocations() { - Loc.flatten(); - for (const auto &I : pathImpl) - I->flattenLocations(); - } - - /// Profiles the diagnostic, independent of the path it references. - /// - /// This can be used to merge diagnostics that refer to the same issue - /// along different paths. - void Profile(llvm::FoldingSetNodeID &ID) const; - - /// Profiles the diagnostic, including its path. - /// - /// Two diagnostics with the same issue along different paths will generate - /// different profiles. - void FullProfile(llvm::FoldingSetNodeID &ID) const; -}; - -} // namespace ento -} // namespace clang - -#endif // LLVM_CLANG_STATICANALYZER_CORE_BUGREPORTER_PATHDIAGNOSTIC_H Index: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h =================================================================== --- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h +++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h @@ -15,9 +15,9 @@ #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H #include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" namespace clang { Index: cfe/trunk/lib/Analysis/CMakeLists.txt =================================================================== --- cfe/trunk/lib/Analysis/CMakeLists.txt +++ cfe/trunk/lib/Analysis/CMakeLists.txt @@ -18,6 +18,7 @@ ExprMutationAnalyzer.cpp LiveVariables.cpp ObjCNoReturn.cpp + PathDiagnostic.cpp PostOrderCFGView.cpp ProgramPoint.cpp ReachableCode.cpp Index: cfe/trunk/lib/Analysis/PathDiagnostic.cpp =================================================================== --- cfe/trunk/lib/Analysis/PathDiagnostic.cpp +++ cfe/trunk/lib/Analysis/PathDiagnostic.cpp @@ -0,0 +1,1215 @@ +//===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the PathDiagnostic-related interfaces. +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/PathDiagnostic.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclBase.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclObjC.h" +#include "clang/AST/DeclTemplate.h" +#include "clang/AST/Expr.h" +#include "clang/AST/ExprCXX.h" +#include "clang/AST/OperationKinds.h" +#include "clang/AST/ParentMap.h" +#include "clang/AST/Stmt.h" +#include "clang/AST/Type.h" +#include "clang/Analysis/AnalysisDeclContext.h" +#include "clang/Analysis/CFG.h" +#include "clang/Analysis/ProgramPoint.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/SourceManager.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/None.h" +#include "llvm/ADT/Optional.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringExtras.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/raw_ostream.h" +#include +#include +#include +#include +#include + +using namespace clang; +using namespace ento; + +static StringRef StripTrailingDots(StringRef s) { + for (StringRef::size_type i = s.size(); i != 0; --i) + if (s[i - 1] != '.') + return s.substr(0, i); + return {}; +} + +PathDiagnosticPiece::PathDiagnosticPiece(StringRef s, + Kind k, DisplayHint hint) + : str(StripTrailingDots(s)), kind(k), Hint(hint) {} + +PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint) + : kind(k), Hint(hint) {} + +PathDiagnosticPiece::~PathDiagnosticPiece() = default; + +PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default; + +PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default; + +PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default; + +PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default; + +PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default; + +PathDiagnosticPopUpPiece::~PathDiagnosticPopUpPiece() = default; + +void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current, + bool ShouldFlattenMacros) const { + for (auto &Piece : *this) { + switch (Piece->getKind()) { + case PathDiagnosticPiece::Call: { + auto &Call = cast(*Piece); + if (auto CallEnter = Call.getCallEnterEvent()) + Current.push_back(std::move(CallEnter)); + Call.path.flattenTo(Primary, Primary, ShouldFlattenMacros); + if (auto callExit = Call.getCallExitEvent()) + Current.push_back(std::move(callExit)); + break; + } + case PathDiagnosticPiece::Macro: { + auto &Macro = cast(*Piece); + if (ShouldFlattenMacros) { + Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros); + } else { + Current.push_back(Piece); + PathPieces NewPath; + Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros); + // FIXME: This probably shouldn't mutate the original path piece. + Macro.subPieces = NewPath; + } + break; + } + case PathDiagnosticPiece::Event: + case PathDiagnosticPiece::ControlFlow: + case PathDiagnosticPiece::Note: + case PathDiagnosticPiece::PopUp: + Current.push_back(Piece); + break; + } + } +} + +PathDiagnostic::~PathDiagnostic() = default; + +PathDiagnostic::PathDiagnostic( + StringRef CheckName, const Decl *declWithIssue, StringRef bugtype, + StringRef verboseDesc, StringRef shortDesc, StringRef category, + PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique, + std::unique_ptr ExecutedLines) + : CheckName(CheckName), DeclWithIssue(declWithIssue), + BugType(StripTrailingDots(bugtype)), + VerboseDesc(StripTrailingDots(verboseDesc)), + ShortDesc(StripTrailingDots(shortDesc)), + Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique), + UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)), + path(pathImpl) {} + +void PathDiagnosticConsumer::anchor() {} + +PathDiagnosticConsumer::~PathDiagnosticConsumer() { + // Delete the contents of the FoldingSet if it isn't empty already. + for (auto &Diag : Diags) + delete &Diag; +} + +void PathDiagnosticConsumer::HandlePathDiagnostic( + std::unique_ptr D) { + if (!D || D->path.empty()) + return; + + // We need to flatten the locations (convert Stmt* to locations) because + // the referenced statements may be freed by the time the diagnostics + // are emitted. + D->flattenLocations(); + + // If the PathDiagnosticConsumer does not support diagnostics that + // cross file boundaries, prune out such diagnostics now. + if (!supportsCrossFileDiagnostics()) { + // Verify that the entire path is from the same FileID. + FileID FID; + const SourceManager &SMgr = D->path.front()->getLocation().getManager(); + SmallVector WorkList; + WorkList.push_back(&D->path); + SmallString<128> buf; + llvm::raw_svector_ostream warning(buf); + warning << "warning: Path diagnostic report is not generated. Current " + << "output format does not support diagnostics that cross file " + << "boundaries. Refer to --analyzer-output for valid output " + << "formats\n"; + + while (!WorkList.empty()) { + const PathPieces &path = *WorkList.pop_back_val(); + + for (const auto &I : path) { + const PathDiagnosticPiece *piece = I.get(); + FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc(); + + if (FID.isInvalid()) { + FID = SMgr.getFileID(L); + } else if (SMgr.getFileID(L) != FID) { + llvm::errs() << warning.str(); + return; + } + + // Check the source ranges. + ArrayRef Ranges = piece->getRanges(); + for (const auto &I : Ranges) { + SourceLocation L = SMgr.getExpansionLoc(I.getBegin()); + if (!L.isFileID() || SMgr.getFileID(L) != FID) { + llvm::errs() << warning.str(); + return; + } + L = SMgr.getExpansionLoc(I.getEnd()); + if (!L.isFileID() || SMgr.getFileID(L) != FID) { + llvm::errs() << warning.str(); + return; + } + } + + if (const auto *call = dyn_cast(piece)) + WorkList.push_back(&call->path); + else if (const auto *macro = dyn_cast(piece)) + WorkList.push_back(¯o->subPieces); + } + } + + if (FID.isInvalid()) + return; // FIXME: Emit a warning? + } + + // Profile the node to see if we already have something matching it + llvm::FoldingSetNodeID profile; + D->Profile(profile); + void *InsertPos = nullptr; + + if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) { + // Keep the PathDiagnostic with the shorter path. + // Note, the enclosing routine is called in deterministic order, so the + // results will be consistent between runs (no reason to break ties if the + // size is the same). + const unsigned orig_size = orig->full_size(); + const unsigned new_size = D->full_size(); + if (orig_size <= new_size) + return; + + assert(orig != D.get()); + Diags.RemoveNode(orig); + delete orig; + } + + Diags.InsertNode(D.release()); +} + +static Optional comparePath(const PathPieces &X, const PathPieces &Y); + +static Optional +compareControlFlow(const PathDiagnosticControlFlowPiece &X, + const PathDiagnosticControlFlowPiece &Y) { + FullSourceLoc XSL = X.getStartLocation().asLocation(); + FullSourceLoc YSL = Y.getStartLocation().asLocation(); + if (XSL != YSL) + return XSL.isBeforeInTranslationUnitThan(YSL); + FullSourceLoc XEL = X.getEndLocation().asLocation(); + FullSourceLoc YEL = Y.getEndLocation().asLocation(); + if (XEL != YEL) + return XEL.isBeforeInTranslationUnitThan(YEL); + return None; +} + +static Optional compareMacro(const PathDiagnosticMacroPiece &X, + const PathDiagnosticMacroPiece &Y) { + return comparePath(X.subPieces, Y.subPieces); +} + +static Optional compareCall(const PathDiagnosticCallPiece &X, + const PathDiagnosticCallPiece &Y) { + FullSourceLoc X_CEL = X.callEnter.asLocation(); + FullSourceLoc Y_CEL = Y.callEnter.asLocation(); + if (X_CEL != Y_CEL) + return X_CEL.isBeforeInTranslationUnitThan(Y_CEL); + FullSourceLoc X_CEWL = X.callEnterWithin.asLocation(); + FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation(); + if (X_CEWL != Y_CEWL) + return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL); + FullSourceLoc X_CRL = X.callReturn.asLocation(); + FullSourceLoc Y_CRL = Y.callReturn.asLocation(); + if (X_CRL != Y_CRL) + return X_CRL.isBeforeInTranslationUnitThan(Y_CRL); + return comparePath(X.path, Y.path); +} + +static Optional comparePiece(const PathDiagnosticPiece &X, + const PathDiagnosticPiece &Y) { + if (X.getKind() != Y.getKind()) + return X.getKind() < Y.getKind(); + + FullSourceLoc XL = X.getLocation().asLocation(); + FullSourceLoc YL = Y.getLocation().asLocation(); + if (XL != YL) + return XL.isBeforeInTranslationUnitThan(YL); + + if (X.getString() != Y.getString()) + return X.getString() < Y.getString(); + + if (X.getRanges().size() != Y.getRanges().size()) + return X.getRanges().size() < Y.getRanges().size(); + + const SourceManager &SM = XL.getManager(); + + for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) { + SourceRange XR = X.getRanges()[i]; + SourceRange YR = Y.getRanges()[i]; + if (XR != YR) { + if (XR.getBegin() != YR.getBegin()) + return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin()); + return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd()); + } + } + + switch (X.getKind()) { + case PathDiagnosticPiece::ControlFlow: + return compareControlFlow(cast(X), + cast(Y)); + case PathDiagnosticPiece::Macro: + return compareMacro(cast(X), + cast(Y)); + case PathDiagnosticPiece::Call: + return compareCall(cast(X), + cast(Y)); + case PathDiagnosticPiece::Event: + case PathDiagnosticPiece::Note: + case PathDiagnosticPiece::PopUp: + return None; + } + llvm_unreachable("all cases handled"); +} + +static Optional comparePath(const PathPieces &X, const PathPieces &Y) { + if (X.size() != Y.size()) + return X.size() < Y.size(); + + PathPieces::const_iterator X_I = X.begin(), X_end = X.end(); + PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end(); + + for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) { + Optional b = comparePiece(**X_I, **Y_I); + if (b.hasValue()) + return b.getValue(); + } + + return None; +} + +static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) { + std::pair XOffs = XL.getDecomposedLoc(); + std::pair YOffs = YL.getDecomposedLoc(); + const SourceManager &SM = XL.getManager(); + std::pair InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs); + if (InSameTU.first) + return XL.isBeforeInTranslationUnitThan(YL); + const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID()); + const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID()); + if (!XFE || !YFE) + return XFE && !YFE; + int NameCmp = XFE->getName().compare(YFE->getName()); + if (NameCmp != 0) + return NameCmp == -1; + // Last resort: Compare raw file IDs that are possibly expansions. + return XL.getFileID() < YL.getFileID(); +} + +static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) { + FullSourceLoc XL = X.getLocation().asLocation(); + FullSourceLoc YL = Y.getLocation().asLocation(); + if (XL != YL) + return compareCrossTUSourceLocs(XL, YL); + if (X.getBugType() != Y.getBugType()) + return X.getBugType() < Y.getBugType(); + if (X.getCategory() != Y.getCategory()) + return X.getCategory() < Y.getCategory(); + if (X.getVerboseDescription() != Y.getVerboseDescription()) + return X.getVerboseDescription() < Y.getVerboseDescription(); + if (X.getShortDescription() != Y.getShortDescription()) + return X.getShortDescription() < Y.getShortDescription(); + if (X.getDeclWithIssue() != Y.getDeclWithIssue()) { + const Decl *XD = X.getDeclWithIssue(); + if (!XD) + return true; + const Decl *YD = Y.getDeclWithIssue(); + if (!YD) + return false; + SourceLocation XDL = XD->getLocation(); + SourceLocation YDL = YD->getLocation(); + if (XDL != YDL) { + const SourceManager &SM = XL.getManager(); + return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM), + FullSourceLoc(YDL, SM)); + } + } + PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end(); + PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end(); + if (XE - XI != YE - YI) + return (XE - XI) < (YE - YI); + for ( ; XI != XE ; ++XI, ++YI) { + if (*XI != *YI) + return (*XI) < (*YI); + } + Optional b = comparePath(X.path, Y.path); + assert(b.hasValue()); + return b.getValue(); +} + +void PathDiagnosticConsumer::FlushDiagnostics( + PathDiagnosticConsumer::FilesMade *Files) { + if (flushed) + return; + + flushed = true; + + std::vector BatchDiags; + for (const auto &D : Diags) + BatchDiags.push_back(&D); + + // Sort the diagnostics so that they are always emitted in a deterministic + // order. + int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) = + [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) { + assert(*X != *Y && "PathDiagnostics not uniqued!"); + if (compare(**X, **Y)) + return -1; + assert(compare(**Y, **X) && "Not a total order!"); + return 1; + }; + array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp); + + FlushDiagnosticsImpl(BatchDiags, Files); + + // Delete the flushed diagnostics. + for (const auto D : BatchDiags) + delete D; + + // Clear out the FoldingSet. + Diags.clear(); +} + +PathDiagnosticConsumer::FilesMade::~FilesMade() { + for (PDFileEntry &Entry : Set) + Entry.~PDFileEntry(); +} + +void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, + StringRef ConsumerName, + StringRef FileName) { + llvm::FoldingSetNodeID NodeID; + NodeID.Add(PD); + void *InsertPos; + PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); + if (!Entry) { + Entry = Alloc.Allocate(); + Entry = new (Entry) PDFileEntry(NodeID); + Set.InsertNode(Entry, InsertPos); + } + + // Allocate persistent storage for the file name. + char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1); + memcpy(FileName_cstr, FileName.data(), FileName.size()); + + Entry->files.push_back(std::make_pair(ConsumerName, + StringRef(FileName_cstr, + FileName.size()))); +} + +PathDiagnosticConsumer::PDFileEntry::ConsumerFiles * +PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) { + llvm::FoldingSetNodeID NodeID; + NodeID.Add(PD); + void *InsertPos; + PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); + if (!Entry) + return nullptr; + return &Entry->files; +} + +//===----------------------------------------------------------------------===// +// PathDiagnosticLocation methods. +//===----------------------------------------------------------------------===// + +SourceLocation PathDiagnosticLocation::getValidSourceLocation( + const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) { + SourceLocation L = UseEndOfStatement ? S->getEndLoc() : S->getBeginLoc(); + assert(!LAC.isNull() && + "A valid LocationContext or AnalysisDeclContext should be passed to " + "PathDiagnosticLocation upon creation."); + + // S might be a temporary statement that does not have a location in the + // source code, so find an enclosing statement and use its location. + if (!L.isValid()) { + AnalysisDeclContext *ADC; + if (LAC.is()) + ADC = LAC.get()->getAnalysisDeclContext(); + else + ADC = LAC.get(); + + ParentMap &PM = ADC->getParentMap(); + + const Stmt *Parent = S; + do { + Parent = PM.getParent(Parent); + + // In rare cases, we have implicit top-level expressions, + // such as arguments for implicit member initializers. + // In this case, fall back to the start of the body (even if we were + // asked for the statement end location). + if (!Parent) { + const Stmt *Body = ADC->getBody(); + if (Body) + L = Body->getBeginLoc(); + else + L = ADC->getDecl()->getEndLoc(); + break; + } + + L = UseEndOfStatement ? Parent->getEndLoc() : Parent->getBeginLoc(); + } while (!L.isValid()); + } + + // FIXME: Ironically, this assert actually fails in some cases. + //assert(L.isValid()); + return L; +} + +static PathDiagnosticLocation +getLocationForCaller(const StackFrameContext *SFC, + const LocationContext *CallerCtx, + const SourceManager &SM) { + const CFGBlock &Block = *SFC->getCallSiteBlock(); + CFGElement Source = Block[SFC->getIndex()]; + + switch (Source.getKind()) { + case CFGElement::Statement: + case CFGElement::Constructor: + case CFGElement::CXXRecordTypedCall: + return PathDiagnosticLocation(Source.castAs().getStmt(), + SM, CallerCtx); + case CFGElement::Initializer: { + const CFGInitializer &Init = Source.castAs(); + return PathDiagnosticLocation(Init.getInitializer()->getInit(), + SM, CallerCtx); + } + case CFGElement::AutomaticObjectDtor: { + const CFGAutomaticObjDtor &Dtor = Source.castAs(); + return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(), + SM, CallerCtx); + } + case CFGElement::DeleteDtor: { + const CFGDeleteDtor &Dtor = Source.castAs(); + return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx); + } + case CFGElement::BaseDtor: + case CFGElement::MemberDtor: { + const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext(); + if (const Stmt *CallerBody = CallerInfo->getBody()) + return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx); + return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM); + } + case CFGElement::NewAllocator: { + const CFGNewAllocator &Alloc = Source.castAs(); + return PathDiagnosticLocation(Alloc.getAllocatorExpr(), SM, CallerCtx); + } + case CFGElement::TemporaryDtor: { + // Temporary destructors are for temporaries. They die immediately at around + // the location of CXXBindTemporaryExpr. If they are lifetime-extended, + // they'd be dealt with via an AutomaticObjectDtor instead. + const auto &Dtor = Source.castAs(); + return PathDiagnosticLocation::createEnd(Dtor.getBindTemporaryExpr(), SM, + CallerCtx); + } + case CFGElement::ScopeBegin: + case CFGElement::ScopeEnd: + llvm_unreachable("not yet implemented!"); + case CFGElement::LifetimeEnds: + case CFGElement::LoopExit: + llvm_unreachable("CFGElement kind should not be on callsite!"); + } + + llvm_unreachable("Unknown CFGElement kind"); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createBegin(const Decl *D, + const SourceManager &SM) { + return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createBegin(const Stmt *S, + const SourceManager &SM, + LocationOrAnalysisDeclContext LAC) { + return PathDiagnosticLocation(getValidSourceLocation(S, LAC), + SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createEnd(const Stmt *S, + const SourceManager &SM, + LocationOrAnalysisDeclContext LAC) { + if (const auto *CS = dyn_cast(S)) + return createEndBrace(CS, SM); + return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true), + SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO, + const SourceManager &SM) { + return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createConditionalColonLoc( + const ConditionalOperator *CO, + const SourceManager &SM) { + return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME, + const SourceManager &SM) { + + assert(ME->getMemberLoc().isValid() || ME->getBeginLoc().isValid()); + + // In some cases, getMemberLoc isn't valid -- in this case we'll return with + // some other related valid SourceLocation. + if (ME->getMemberLoc().isValid()) + return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK); + + return PathDiagnosticLocation(ME->getBeginLoc(), SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS, + const SourceManager &SM) { + SourceLocation L = CS->getLBracLoc(); + return PathDiagnosticLocation(L, SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS, + const SourceManager &SM) { + SourceLocation L = CS->getRBracLoc(); + return PathDiagnosticLocation(L, SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createDeclBegin(const LocationContext *LC, + const SourceManager &SM) { + // FIXME: Should handle CXXTryStmt if analyser starts supporting C++. + if (const auto *CS = dyn_cast_or_null(LC->getDecl()->getBody())) + if (!CS->body_empty()) { + SourceLocation Loc = (*CS->body_begin())->getBeginLoc(); + return PathDiagnosticLocation(Loc, SM, SingleLocK); + } + + return PathDiagnosticLocation(); +} + +PathDiagnosticLocation +PathDiagnosticLocation::createDeclEnd(const LocationContext *LC, + const SourceManager &SM) { + SourceLocation L = LC->getDecl()->getBodyRBrace(); + return PathDiagnosticLocation(L, SM, SingleLocK); +} + +PathDiagnosticLocation +PathDiagnosticLocation::create(const ProgramPoint& P, + const SourceManager &SMng) { + const Stmt* S = nullptr; + if (Optional BE = P.getAs()) { + const CFGBlock *BSrc = BE->getSrc(); + if (BSrc->getTerminator().isVirtualBaseBranch()) { + // TODO: VirtualBaseBranches should also appear for destructors. + // In this case we should put the diagnostic at the end of decl. + return PathDiagnosticLocation::createBegin( + P.getLocationContext()->getDecl(), SMng); + + } else { + S = BSrc->getTerminatorCondition(); + if (!S) { + // If the BlockEdge has no terminator condition statement but its + // source is the entry of the CFG (e.g. a checker crated the branch at + // the beginning of a function), use the function's declaration instead. + assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no " + "TerminatorCondition and is not the enrty block of the CFG"); + return PathDiagnosticLocation::createBegin( + P.getLocationContext()->getDecl(), SMng); + } + } + } else if (Optional SP = P.getAs()) { + S = SP->getStmt(); + if (P.getAs()) + return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext()); + } else if (Optional PIP = P.getAs()) { + return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(), + SMng); + } else if (Optional PIC = P.getAs()) { + return PathDiagnosticLocation(PIC->getLocation(), SMng); + } else if (Optional PIE = P.getAs()) { + return PathDiagnosticLocation(PIE->getLocation(), SMng); + } else if (Optional CE = P.getAs()) { + return getLocationForCaller(CE->getCalleeContext(), + CE->getLocationContext(), + SMng); + } else if (Optional CEE = P.getAs()) { + return getLocationForCaller(CEE->getCalleeContext(), + CEE->getLocationContext(), + SMng); + } else if (auto CEB = P.getAs()) { + if (const ReturnStmt *RS = CEB->getReturnStmt()) + return PathDiagnosticLocation::createBegin(RS, SMng, + CEB->getLocationContext()); + return PathDiagnosticLocation( + CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng); + } else if (Optional BE = P.getAs()) { + CFGElement BlockFront = BE->getBlock()->front(); + if (auto StmtElt = BlockFront.getAs()) { + return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng); + } else if (auto NewAllocElt = BlockFront.getAs()) { + return PathDiagnosticLocation( + NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng); + } + llvm_unreachable("Unexpected CFG element at front of block"); + } else if (Optional FE = P.getAs()) { + return PathDiagnosticLocation(FE->getStmt(), SMng, + FE->getLocationContext()); + } else { + llvm_unreachable("Unexpected ProgramPoint"); + } + + return PathDiagnosticLocation(S, SMng, P.getLocationContext()); +} + +PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation( + const PathDiagnosticLocation &PDL) { + FullSourceLoc L = PDL.asLocation(); + return PathDiagnosticLocation(L, L.getManager(), SingleLocK); +} + +FullSourceLoc + PathDiagnosticLocation::genLocation(SourceLocation L, + LocationOrAnalysisDeclContext LAC) const { + assert(isValid()); + // Note that we want a 'switch' here so that the compiler can warn us in + // case we add more cases. + switch (K) { + case SingleLocK: + case RangeK: + break; + case StmtK: + // Defensive checking. + if (!S) + break; + return FullSourceLoc(getValidSourceLocation(S, LAC), + const_cast(*SM)); + case DeclK: + // Defensive checking. + if (!D) + break; + return FullSourceLoc(D->getLocation(), const_cast(*SM)); + } + + return FullSourceLoc(L, const_cast(*SM)); +} + +PathDiagnosticRange + PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const { + assert(isValid()); + // Note that we want a 'switch' here so that the compiler can warn us in + // case we add more cases. + switch (K) { + case SingleLocK: + return PathDiagnosticRange(SourceRange(Loc,Loc), true); + case RangeK: + break; + case StmtK: { + const Stmt *S = asStmt(); + switch (S->getStmtClass()) { + default: + break; + case Stmt::DeclStmtClass: { + const auto *DS = cast(S); + if (DS->isSingleDecl()) { + // Should always be the case, but we'll be defensive. + return SourceRange(DS->getBeginLoc(), + DS->getSingleDecl()->getLocation()); + } + break; + } + // FIXME: Provide better range information for different + // terminators. + case Stmt::IfStmtClass: + case Stmt::WhileStmtClass: + case Stmt::DoStmtClass: + case Stmt::ForStmtClass: + case Stmt::ChooseExprClass: + case Stmt::IndirectGotoStmtClass: + case Stmt::SwitchStmtClass: + case Stmt::BinaryConditionalOperatorClass: + case Stmt::ConditionalOperatorClass: + case Stmt::ObjCForCollectionStmtClass: { + SourceLocation L = getValidSourceLocation(S, LAC); + return SourceRange(L, L); + } + } + SourceRange R = S->getSourceRange(); + if (R.isValid()) + return R; + break; + } + case DeclK: + if (const auto *MD = dyn_cast(D)) + return MD->getSourceRange(); + if (const auto *FD = dyn_cast(D)) { + if (Stmt *Body = FD->getBody()) + return Body->getSourceRange(); + } + else { + SourceLocation L = D->getLocation(); + return PathDiagnosticRange(SourceRange(L, L), true); + } + } + + return SourceRange(Loc, Loc); +} + +void PathDiagnosticLocation::flatten() { + if (K == StmtK) { + K = RangeK; + S = nullptr; + D = nullptr; + } + else if (K == DeclK) { + K = SingleLocK; + S = nullptr; + D = nullptr; + } +} + +//===----------------------------------------------------------------------===// +// Manipulation of PathDiagnosticCallPieces. +//===----------------------------------------------------------------------===// + +std::shared_ptr +PathDiagnosticCallPiece::construct(const CallExitEnd &CE, + const SourceManager &SM) { + const Decl *caller = CE.getLocationContext()->getDecl(); + PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(), + CE.getLocationContext(), + SM); + return std::shared_ptr( + new PathDiagnosticCallPiece(caller, pos)); +} + +PathDiagnosticCallPiece * +PathDiagnosticCallPiece::construct(PathPieces &path, + const Decl *caller) { + std::shared_ptr C( + new PathDiagnosticCallPiece(path, caller)); + path.clear(); + auto *R = C.get(); + path.push_front(std::move(C)); + return R; +} + +void PathDiagnosticCallPiece::setCallee(const CallEnter &CE, + const SourceManager &SM) { + const StackFrameContext *CalleeCtx = CE.getCalleeContext(); + Callee = CalleeCtx->getDecl(); + + callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM); + callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM); + + // Autosynthesized property accessors are special because we'd never + // pop back up to non-autosynthesized code until we leave them. + // This is not generally true for autosynthesized callees, which may call + // non-autosynthesized callbacks. + // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag + // defaults to false. + if (const auto *MD = dyn_cast(Callee)) + IsCalleeAnAutosynthesizedPropertyAccessor = ( + MD->isPropertyAccessor() && + CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized()); +} + +static void describeTemplateParameters(raw_ostream &Out, + const ArrayRef TAList, + const LangOptions &LO, + StringRef Prefix = StringRef(), + StringRef Postfix = StringRef()); + +static void describeTemplateParameter(raw_ostream &Out, + const TemplateArgument &TArg, + const LangOptions &LO) { + + if (TArg.getKind() == TemplateArgument::ArgKind::Pack) { + describeTemplateParameters(Out, TArg.getPackAsArray(), LO); + } else { + TArg.print(PrintingPolicy(LO), Out); + } +} + +static void describeTemplateParameters(raw_ostream &Out, + const ArrayRef TAList, + const LangOptions &LO, + StringRef Prefix, StringRef Postfix) { + if (TAList.empty()) + return; + + Out << Prefix; + for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) { + describeTemplateParameter(Out, TAList[I], LO); + Out << ", "; + } + describeTemplateParameter(Out, TAList[TAList.size() - 1], LO); + Out << Postfix; +} + +static void describeClass(raw_ostream &Out, const CXXRecordDecl *D, + StringRef Prefix = StringRef()) { + if (!D->getIdentifier()) + return; + Out << Prefix << '\'' << *D; + if (const auto T = dyn_cast(D)) + describeTemplateParameters(Out, T->getTemplateArgs().asArray(), + D->getASTContext().getLangOpts(), "<", ">"); + + Out << '\''; +} + +static bool describeCodeDecl(raw_ostream &Out, const Decl *D, + bool ExtendedDescription, + StringRef Prefix = StringRef()) { + if (!D) + return false; + + if (isa(D)) { + if (ExtendedDescription) + Out << Prefix << "anonymous block"; + return ExtendedDescription; + } + + if (const auto *MD = dyn_cast(D)) { + Out << Prefix; + if (ExtendedDescription && !MD->isUserProvided()) { + if (MD->isExplicitlyDefaulted()) + Out << "defaulted "; + else + Out << "implicit "; + } + + if (const auto *CD = dyn_cast(MD)) { + if (CD->isDefaultConstructor()) + Out << "default "; + else if (CD->isCopyConstructor()) + Out << "copy "; + else if (CD->isMoveConstructor()) + Out << "move "; + + Out << "constructor"; + describeClass(Out, MD->getParent(), " for "); + } else if (isa(MD)) { + if (!MD->isUserProvided()) { + Out << "destructor"; + describeClass(Out, MD->getParent(), " for "); + } else { + // Use ~Foo for explicitly-written destructors. + Out << "'" << *MD << "'"; + } + } else if (MD->isCopyAssignmentOperator()) { + Out << "copy assignment operator"; + describeClass(Out, MD->getParent(), " for "); + } else if (MD->isMoveAssignmentOperator()) { + Out << "move assignment operator"; + describeClass(Out, MD->getParent(), " for "); + } else { + if (MD->getParent()->getIdentifier()) + Out << "'" << *MD->getParent() << "::" << *MD << "'"; + else + Out << "'" << *MD << "'"; + } + + return true; + } + + Out << Prefix << '\'' << cast(*D); + + // Adding template parameters. + if (const auto FD = dyn_cast(D)) + if (const TemplateArgumentList *TAList = + FD->getTemplateSpecializationArgs()) + describeTemplateParameters(Out, TAList->asArray(), + FD->getASTContext().getLangOpts(), "<", ">"); + + Out << '\''; + return true; +} + +std::shared_ptr +PathDiagnosticCallPiece::getCallEnterEvent() const { + // We do not produce call enters and call exits for autosynthesized property + // accessors. We do generally produce them for other functions coming from + // the body farm because they may call callbacks that bring us back into + // visible code. + if (!Callee || IsCalleeAnAutosynthesizedPropertyAccessor) + return nullptr; + + SmallString<256> buf; + llvm::raw_svector_ostream Out(buf); + + Out << "Calling "; + describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true); + + assert(callEnter.asLocation().isValid()); + return std::make_shared(callEnter, Out.str()); +} + +std::shared_ptr +PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const { + if (!callEnterWithin.asLocation().isValid()) + return nullptr; + if (Callee->isImplicit() || !Callee->hasBody()) + return nullptr; + if (const auto *MD = dyn_cast(Callee)) + if (MD->isDefaulted()) + return nullptr; + + SmallString<256> buf; + llvm::raw_svector_ostream Out(buf); + + Out << "Entered call"; + describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from "); + + return std::make_shared(callEnterWithin, Out.str()); +} + +std::shared_ptr +PathDiagnosticCallPiece::getCallExitEvent() const { + // We do not produce call enters and call exits for autosynthesized property + // accessors. We do generally produce them for other functions coming from + // the body farm because they may call callbacks that bring us back into + // visible code. + if (NoExit || IsCalleeAnAutosynthesizedPropertyAccessor) + return nullptr; + + SmallString<256> buf; + llvm::raw_svector_ostream Out(buf); + + if (!CallStackMessage.empty()) { + Out << CallStackMessage; + } else { + bool DidDescribe = describeCodeDecl(Out, Callee, + /*ExtendedDescription=*/false, + "Returning from "); + if (!DidDescribe) + Out << "Returning to caller"; + } + + assert(callReturn.asLocation().isValid()); + return std::make_shared(callReturn, Out.str()); +} + +static void compute_path_size(const PathPieces &pieces, unsigned &size) { + for (const auto &I : pieces) { + const PathDiagnosticPiece *piece = I.get(); + if (const auto *cp = dyn_cast(piece)) + compute_path_size(cp->path, size); + else + ++size; + } +} + +unsigned PathDiagnostic::full_size() { + unsigned size = 0; + compute_path_size(path, size); + return size; +} + +//===----------------------------------------------------------------------===// +// FoldingSet profiling methods. +//===----------------------------------------------------------------------===// + +void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const { + ID.AddInteger(Range.getBegin().getRawEncoding()); + ID.AddInteger(Range.getEnd().getRawEncoding()); + ID.AddInteger(Loc.getRawEncoding()); +} + +void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const { + ID.AddInteger((unsigned) getKind()); + ID.AddString(str); + // FIXME: Add profiling support for code hints. + ID.AddInteger((unsigned) getDisplayHint()); + ArrayRef Ranges = getRanges(); + for (const auto &I : Ranges) { + ID.AddInteger(I.getBegin().getRawEncoding()); + ID.AddInteger(I.getEnd().getRawEncoding()); + } +} + +void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticPiece::Profile(ID); + for (const auto &I : path) + ID.Add(*I); +} + +void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticPiece::Profile(ID); + ID.Add(Pos); +} + +void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticPiece::Profile(ID); + for (const auto &I : *this) + ID.Add(I); +} + +void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticSpotPiece::Profile(ID); + for (const auto &I : subPieces) + ID.Add(*I); +} + +void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticSpotPiece::Profile(ID); +} + +void PathDiagnosticPopUpPiece::Profile(llvm::FoldingSetNodeID &ID) const { + PathDiagnosticSpotPiece::Profile(ID); +} + +void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const { + ID.Add(getLocation()); + ID.AddString(BugType); + ID.AddString(VerboseDesc); + ID.AddString(Category); +} + +void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const { + Profile(ID); + for (const auto &I : path) + ID.Add(*I); + for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I) + ID.AddString(*I); +} + +LLVM_DUMP_METHOD void PathPieces::dump() const { + unsigned index = 0; + for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) { + llvm::errs() << "[" << index++ << "] "; + (*I)->dump(); + llvm::errs() << "\n"; + } +} + +LLVM_DUMP_METHOD void PathDiagnosticCallPiece::dump() const { + llvm::errs() << "CALL\n--------------\n"; + + if (const Stmt *SLoc = getLocation().getStmtOrNull()) + SLoc->dump(); + else if (const auto *ND = dyn_cast_or_null(getCallee())) + llvm::errs() << *ND << "\n"; + else + getLocation().dump(); +} + +LLVM_DUMP_METHOD void PathDiagnosticEventPiece::dump() const { + llvm::errs() << "EVENT\n--------------\n"; + llvm::errs() << getString() << "\n"; + llvm::errs() << " ---- at ----\n"; + getLocation().dump(); +} + +LLVM_DUMP_METHOD void PathDiagnosticControlFlowPiece::dump() const { + llvm::errs() << "CONTROL\n--------------\n"; + getStartLocation().dump(); + llvm::errs() << " ---- to ----\n"; + getEndLocation().dump(); +} + +LLVM_DUMP_METHOD void PathDiagnosticMacroPiece::dump() const { + llvm::errs() << "MACRO\n--------------\n"; + // FIXME: Print which macro is being invoked. +} + +LLVM_DUMP_METHOD void PathDiagnosticNotePiece::dump() const { + llvm::errs() << "NOTE\n--------------\n"; + llvm::errs() << getString() << "\n"; + llvm::errs() << " ---- at ----\n"; + getLocation().dump(); +} + +LLVM_DUMP_METHOD void PathDiagnosticPopUpPiece::dump() const { + llvm::errs() << "POP-UP\n--------------\n"; + llvm::errs() << getString() << "\n"; + llvm::errs() << " ---- at ----\n"; + getLocation().dump(); +} + +LLVM_DUMP_METHOD void PathDiagnosticLocation::dump() const { + if (!isValid()) { + llvm::errs() << "\n"; + return; + } + + switch (K) { + case RangeK: + // FIXME: actually print the range. + llvm::errs() << "\n"; + break; + case SingleLocK: + asLocation().dump(); + llvm::errs() << "\n"; + break; + case StmtK: + if (S) + S->dump(); + else + llvm::errs() << "\n"; + break; + case DeclK: + if (const auto *ND = dyn_cast_or_null(D)) + llvm::errs() << *ND << "\n"; + else if (isa(D)) + // FIXME: Make this nicer. + llvm::errs() << "\n"; + else if (D) + llvm::errs() << "\n"; + else + llvm::errs() << "\n"; + break; + } +} Index: cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp +++ cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp @@ -28,6 +28,7 @@ //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/Attr.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" @@ -36,7 +37,6 @@ #include "clang/Basic/TargetInfo.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" Index: cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp +++ cfe/trunk/lib/StaticAnalyzer/Checkers/CheckObjCInstMethSignature.cpp @@ -13,11 +13,11 @@ //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Type.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "llvm/ADT/DenseMap.h" #include "llvm/Support/raw_ostream.h" Index: cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp +++ cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCMissingSuperCallChecker.cpp @@ -13,12 +13,12 @@ //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprObjC.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" #include "llvm/ADT/SmallSet.h" Index: cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp +++ cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp @@ -13,6 +13,7 @@ //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/Attr.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" @@ -20,7 +21,6 @@ #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" using namespace clang; Index: cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h +++ cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h @@ -21,12 +21,12 @@ #include "clang/AST/DeclObjC.h" #include "clang/AST/ParentMap.h" #include "clang/Analysis/DomainSpecific/CocoaConventions.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Analysis/RetainSummaryManager.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/SourceManager.h" #include "clang/Analysis/SelectorExtras.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" Index: cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h +++ cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h @@ -14,10 +14,10 @@ #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_DIAGNOSTICS_H #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_DIAGNOSTICS_H +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Analysis/RetainSummaryManager.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" namespace clang { Index: cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/BugReporter.cpp @@ -24,6 +24,7 @@ #include "clang/Analysis/AnalysisDeclContext.h" #include "clang/Analysis/CFG.h" #include "clang/Analysis/CFGStmtMap.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Analysis/ProgramPoint.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" @@ -31,7 +32,6 @@ #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" Index: cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -26,6 +26,7 @@ #include "clang/Analysis/AnalysisDeclContext.h" #include "clang/Analysis/CFG.h" #include "clang/Analysis/CFGStmtMap.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Analysis/ProgramPoint.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" @@ -34,7 +35,6 @@ #include "clang/Lex/Lexer.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" Index: cfe/trunk/lib/StaticAnalyzer/Core/CMakeLists.txt =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/CMakeLists.txt +++ cfe/trunk/lib/StaticAnalyzer/Core/CMakeLists.txt @@ -30,7 +30,6 @@ LoopUnrolling.cpp LoopWidening.cpp MemRegion.cpp - PathDiagnostic.cpp PlistDiagnostics.cpp ProgramState.cpp RangeConstraintManager.cpp Index: cfe/trunk/lib/StaticAnalyzer/Core/CallEvent.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/CallEvent.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/CallEvent.cpp @@ -27,6 +27,7 @@ #include "clang/Analysis/AnalysisDeclContext.h" #include "clang/Analysis/CFG.h" #include "clang/Analysis/CFGStmtMap.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Analysis/ProgramPoint.h" #include "clang/CrossTU/CrossTranslationUnit.h" #include "clang/Basic/IdentifierTable.h" @@ -34,7 +35,6 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/Specifiers.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h" #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h" Index: cfe/trunk/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/Stmt.h" @@ -23,7 +24,6 @@ #include "clang/Rewrite/Core/HTMLRewrite.h" #include "clang/Rewrite/Core/Rewriter.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/IssueHash.h" #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" #include "llvm/ADT/ArrayRef.h" Index: cfe/trunk/lib/StaticAnalyzer/Core/PathDiagnostic.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/PathDiagnostic.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/PathDiagnostic.cpp @@ -1,1215 +0,0 @@ -//===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// -// -// This file defines the PathDiagnostic-related interfaces. -// -//===----------------------------------------------------------------------===// - -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" -#include "clang/AST/Decl.h" -#include "clang/AST/DeclBase.h" -#include "clang/AST/DeclCXX.h" -#include "clang/AST/DeclObjC.h" -#include "clang/AST/DeclTemplate.h" -#include "clang/AST/Expr.h" -#include "clang/AST/ExprCXX.h" -#include "clang/AST/OperationKinds.h" -#include "clang/AST/ParentMap.h" -#include "clang/AST/Stmt.h" -#include "clang/AST/Type.h" -#include "clang/Analysis/AnalysisDeclContext.h" -#include "clang/Analysis/CFG.h" -#include "clang/Analysis/ProgramPoint.h" -#include "clang/Basic/FileManager.h" -#include "clang/Basic/LLVM.h" -#include "clang/Basic/SourceLocation.h" -#include "clang/Basic/SourceManager.h" -#include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/FoldingSet.h" -#include "llvm/ADT/None.h" -#include "llvm/ADT/Optional.h" -#include "llvm/ADT/STLExtras.h" -#include "llvm/ADT/SmallString.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/StringExtras.h" -#include "llvm/ADT/StringRef.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/raw_ostream.h" -#include -#include -#include -#include -#include - -using namespace clang; -using namespace ento; - -static StringRef StripTrailingDots(StringRef s) { - for (StringRef::size_type i = s.size(); i != 0; --i) - if (s[i - 1] != '.') - return s.substr(0, i); - return {}; -} - -PathDiagnosticPiece::PathDiagnosticPiece(StringRef s, - Kind k, DisplayHint hint) - : str(StripTrailingDots(s)), kind(k), Hint(hint) {} - -PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint) - : kind(k), Hint(hint) {} - -PathDiagnosticPiece::~PathDiagnosticPiece() = default; - -PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default; - -PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default; - -PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default; - -PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default; - -PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default; - -PathDiagnosticPopUpPiece::~PathDiagnosticPopUpPiece() = default; - -void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current, - bool ShouldFlattenMacros) const { - for (auto &Piece : *this) { - switch (Piece->getKind()) { - case PathDiagnosticPiece::Call: { - auto &Call = cast(*Piece); - if (auto CallEnter = Call.getCallEnterEvent()) - Current.push_back(std::move(CallEnter)); - Call.path.flattenTo(Primary, Primary, ShouldFlattenMacros); - if (auto callExit = Call.getCallExitEvent()) - Current.push_back(std::move(callExit)); - break; - } - case PathDiagnosticPiece::Macro: { - auto &Macro = cast(*Piece); - if (ShouldFlattenMacros) { - Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros); - } else { - Current.push_back(Piece); - PathPieces NewPath; - Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros); - // FIXME: This probably shouldn't mutate the original path piece. - Macro.subPieces = NewPath; - } - break; - } - case PathDiagnosticPiece::Event: - case PathDiagnosticPiece::ControlFlow: - case PathDiagnosticPiece::Note: - case PathDiagnosticPiece::PopUp: - Current.push_back(Piece); - break; - } - } -} - -PathDiagnostic::~PathDiagnostic() = default; - -PathDiagnostic::PathDiagnostic( - StringRef CheckName, const Decl *declWithIssue, StringRef bugtype, - StringRef verboseDesc, StringRef shortDesc, StringRef category, - PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique, - std::unique_ptr ExecutedLines) - : CheckName(CheckName), DeclWithIssue(declWithIssue), - BugType(StripTrailingDots(bugtype)), - VerboseDesc(StripTrailingDots(verboseDesc)), - ShortDesc(StripTrailingDots(shortDesc)), - Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique), - UniqueingDecl(DeclToUnique), ExecutedLines(std::move(ExecutedLines)), - path(pathImpl) {} - -void PathDiagnosticConsumer::anchor() {} - -PathDiagnosticConsumer::~PathDiagnosticConsumer() { - // Delete the contents of the FoldingSet if it isn't empty already. - for (auto &Diag : Diags) - delete &Diag; -} - -void PathDiagnosticConsumer::HandlePathDiagnostic( - std::unique_ptr D) { - if (!D || D->path.empty()) - return; - - // We need to flatten the locations (convert Stmt* to locations) because - // the referenced statements may be freed by the time the diagnostics - // are emitted. - D->flattenLocations(); - - // If the PathDiagnosticConsumer does not support diagnostics that - // cross file boundaries, prune out such diagnostics now. - if (!supportsCrossFileDiagnostics()) { - // Verify that the entire path is from the same FileID. - FileID FID; - const SourceManager &SMgr = D->path.front()->getLocation().getManager(); - SmallVector WorkList; - WorkList.push_back(&D->path); - SmallString<128> buf; - llvm::raw_svector_ostream warning(buf); - warning << "warning: Path diagnostic report is not generated. Current " - << "output format does not support diagnostics that cross file " - << "boundaries. Refer to --analyzer-output for valid output " - << "formats\n"; - - while (!WorkList.empty()) { - const PathPieces &path = *WorkList.pop_back_val(); - - for (const auto &I : path) { - const PathDiagnosticPiece *piece = I.get(); - FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc(); - - if (FID.isInvalid()) { - FID = SMgr.getFileID(L); - } else if (SMgr.getFileID(L) != FID) { - llvm::errs() << warning.str(); - return; - } - - // Check the source ranges. - ArrayRef Ranges = piece->getRanges(); - for (const auto &I : Ranges) { - SourceLocation L = SMgr.getExpansionLoc(I.getBegin()); - if (!L.isFileID() || SMgr.getFileID(L) != FID) { - llvm::errs() << warning.str(); - return; - } - L = SMgr.getExpansionLoc(I.getEnd()); - if (!L.isFileID() || SMgr.getFileID(L) != FID) { - llvm::errs() << warning.str(); - return; - } - } - - if (const auto *call = dyn_cast(piece)) - WorkList.push_back(&call->path); - else if (const auto *macro = dyn_cast(piece)) - WorkList.push_back(¯o->subPieces); - } - } - - if (FID.isInvalid()) - return; // FIXME: Emit a warning? - } - - // Profile the node to see if we already have something matching it - llvm::FoldingSetNodeID profile; - D->Profile(profile); - void *InsertPos = nullptr; - - if (PathDiagnostic *orig = Diags.FindNodeOrInsertPos(profile, InsertPos)) { - // Keep the PathDiagnostic with the shorter path. - // Note, the enclosing routine is called in deterministic order, so the - // results will be consistent between runs (no reason to break ties if the - // size is the same). - const unsigned orig_size = orig->full_size(); - const unsigned new_size = D->full_size(); - if (orig_size <= new_size) - return; - - assert(orig != D.get()); - Diags.RemoveNode(orig); - delete orig; - } - - Diags.InsertNode(D.release()); -} - -static Optional comparePath(const PathPieces &X, const PathPieces &Y); - -static Optional -compareControlFlow(const PathDiagnosticControlFlowPiece &X, - const PathDiagnosticControlFlowPiece &Y) { - FullSourceLoc XSL = X.getStartLocation().asLocation(); - FullSourceLoc YSL = Y.getStartLocation().asLocation(); - if (XSL != YSL) - return XSL.isBeforeInTranslationUnitThan(YSL); - FullSourceLoc XEL = X.getEndLocation().asLocation(); - FullSourceLoc YEL = Y.getEndLocation().asLocation(); - if (XEL != YEL) - return XEL.isBeforeInTranslationUnitThan(YEL); - return None; -} - -static Optional compareMacro(const PathDiagnosticMacroPiece &X, - const PathDiagnosticMacroPiece &Y) { - return comparePath(X.subPieces, Y.subPieces); -} - -static Optional compareCall(const PathDiagnosticCallPiece &X, - const PathDiagnosticCallPiece &Y) { - FullSourceLoc X_CEL = X.callEnter.asLocation(); - FullSourceLoc Y_CEL = Y.callEnter.asLocation(); - if (X_CEL != Y_CEL) - return X_CEL.isBeforeInTranslationUnitThan(Y_CEL); - FullSourceLoc X_CEWL = X.callEnterWithin.asLocation(); - FullSourceLoc Y_CEWL = Y.callEnterWithin.asLocation(); - if (X_CEWL != Y_CEWL) - return X_CEWL.isBeforeInTranslationUnitThan(Y_CEWL); - FullSourceLoc X_CRL = X.callReturn.asLocation(); - FullSourceLoc Y_CRL = Y.callReturn.asLocation(); - if (X_CRL != Y_CRL) - return X_CRL.isBeforeInTranslationUnitThan(Y_CRL); - return comparePath(X.path, Y.path); -} - -static Optional comparePiece(const PathDiagnosticPiece &X, - const PathDiagnosticPiece &Y) { - if (X.getKind() != Y.getKind()) - return X.getKind() < Y.getKind(); - - FullSourceLoc XL = X.getLocation().asLocation(); - FullSourceLoc YL = Y.getLocation().asLocation(); - if (XL != YL) - return XL.isBeforeInTranslationUnitThan(YL); - - if (X.getString() != Y.getString()) - return X.getString() < Y.getString(); - - if (X.getRanges().size() != Y.getRanges().size()) - return X.getRanges().size() < Y.getRanges().size(); - - const SourceManager &SM = XL.getManager(); - - for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) { - SourceRange XR = X.getRanges()[i]; - SourceRange YR = Y.getRanges()[i]; - if (XR != YR) { - if (XR.getBegin() != YR.getBegin()) - return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin()); - return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd()); - } - } - - switch (X.getKind()) { - case PathDiagnosticPiece::ControlFlow: - return compareControlFlow(cast(X), - cast(Y)); - case PathDiagnosticPiece::Macro: - return compareMacro(cast(X), - cast(Y)); - case PathDiagnosticPiece::Call: - return compareCall(cast(X), - cast(Y)); - case PathDiagnosticPiece::Event: - case PathDiagnosticPiece::Note: - case PathDiagnosticPiece::PopUp: - return None; - } - llvm_unreachable("all cases handled"); -} - -static Optional comparePath(const PathPieces &X, const PathPieces &Y) { - if (X.size() != Y.size()) - return X.size() < Y.size(); - - PathPieces::const_iterator X_I = X.begin(), X_end = X.end(); - PathPieces::const_iterator Y_I = Y.begin(), Y_end = Y.end(); - - for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) { - Optional b = comparePiece(**X_I, **Y_I); - if (b.hasValue()) - return b.getValue(); - } - - return None; -} - -static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) { - std::pair XOffs = XL.getDecomposedLoc(); - std::pair YOffs = YL.getDecomposedLoc(); - const SourceManager &SM = XL.getManager(); - std::pair InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs); - if (InSameTU.first) - return XL.isBeforeInTranslationUnitThan(YL); - const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID()); - const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID()); - if (!XFE || !YFE) - return XFE && !YFE; - int NameCmp = XFE->getName().compare(YFE->getName()); - if (NameCmp != 0) - return NameCmp == -1; - // Last resort: Compare raw file IDs that are possibly expansions. - return XL.getFileID() < YL.getFileID(); -} - -static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) { - FullSourceLoc XL = X.getLocation().asLocation(); - FullSourceLoc YL = Y.getLocation().asLocation(); - if (XL != YL) - return compareCrossTUSourceLocs(XL, YL); - if (X.getBugType() != Y.getBugType()) - return X.getBugType() < Y.getBugType(); - if (X.getCategory() != Y.getCategory()) - return X.getCategory() < Y.getCategory(); - if (X.getVerboseDescription() != Y.getVerboseDescription()) - return X.getVerboseDescription() < Y.getVerboseDescription(); - if (X.getShortDescription() != Y.getShortDescription()) - return X.getShortDescription() < Y.getShortDescription(); - if (X.getDeclWithIssue() != Y.getDeclWithIssue()) { - const Decl *XD = X.getDeclWithIssue(); - if (!XD) - return true; - const Decl *YD = Y.getDeclWithIssue(); - if (!YD) - return false; - SourceLocation XDL = XD->getLocation(); - SourceLocation YDL = YD->getLocation(); - if (XDL != YDL) { - const SourceManager &SM = XL.getManager(); - return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM), - FullSourceLoc(YDL, SM)); - } - } - PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end(); - PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end(); - if (XE - XI != YE - YI) - return (XE - XI) < (YE - YI); - for ( ; XI != XE ; ++XI, ++YI) { - if (*XI != *YI) - return (*XI) < (*YI); - } - Optional b = comparePath(X.path, Y.path); - assert(b.hasValue()); - return b.getValue(); -} - -void PathDiagnosticConsumer::FlushDiagnostics( - PathDiagnosticConsumer::FilesMade *Files) { - if (flushed) - return; - - flushed = true; - - std::vector BatchDiags; - for (const auto &D : Diags) - BatchDiags.push_back(&D); - - // Sort the diagnostics so that they are always emitted in a deterministic - // order. - int (*Comp)(const PathDiagnostic *const *, const PathDiagnostic *const *) = - [](const PathDiagnostic *const *X, const PathDiagnostic *const *Y) { - assert(*X != *Y && "PathDiagnostics not uniqued!"); - if (compare(**X, **Y)) - return -1; - assert(compare(**Y, **X) && "Not a total order!"); - return 1; - }; - array_pod_sort(BatchDiags.begin(), BatchDiags.end(), Comp); - - FlushDiagnosticsImpl(BatchDiags, Files); - - // Delete the flushed diagnostics. - for (const auto D : BatchDiags) - delete D; - - // Clear out the FoldingSet. - Diags.clear(); -} - -PathDiagnosticConsumer::FilesMade::~FilesMade() { - for (PDFileEntry &Entry : Set) - Entry.~PDFileEntry(); -} - -void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, - StringRef ConsumerName, - StringRef FileName) { - llvm::FoldingSetNodeID NodeID; - NodeID.Add(PD); - void *InsertPos; - PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); - if (!Entry) { - Entry = Alloc.Allocate(); - Entry = new (Entry) PDFileEntry(NodeID); - Set.InsertNode(Entry, InsertPos); - } - - // Allocate persistent storage for the file name. - char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1); - memcpy(FileName_cstr, FileName.data(), FileName.size()); - - Entry->files.push_back(std::make_pair(ConsumerName, - StringRef(FileName_cstr, - FileName.size()))); -} - -PathDiagnosticConsumer::PDFileEntry::ConsumerFiles * -PathDiagnosticConsumer::FilesMade::getFiles(const PathDiagnostic &PD) { - llvm::FoldingSetNodeID NodeID; - NodeID.Add(PD); - void *InsertPos; - PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); - if (!Entry) - return nullptr; - return &Entry->files; -} - -//===----------------------------------------------------------------------===// -// PathDiagnosticLocation methods. -//===----------------------------------------------------------------------===// - -SourceLocation PathDiagnosticLocation::getValidSourceLocation( - const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) { - SourceLocation L = UseEndOfStatement ? S->getEndLoc() : S->getBeginLoc(); - assert(!LAC.isNull() && - "A valid LocationContext or AnalysisDeclContext should be passed to " - "PathDiagnosticLocation upon creation."); - - // S might be a temporary statement that does not have a location in the - // source code, so find an enclosing statement and use its location. - if (!L.isValid()) { - AnalysisDeclContext *ADC; - if (LAC.is()) - ADC = LAC.get()->getAnalysisDeclContext(); - else - ADC = LAC.get(); - - ParentMap &PM = ADC->getParentMap(); - - const Stmt *Parent = S; - do { - Parent = PM.getParent(Parent); - - // In rare cases, we have implicit top-level expressions, - // such as arguments for implicit member initializers. - // In this case, fall back to the start of the body (even if we were - // asked for the statement end location). - if (!Parent) { - const Stmt *Body = ADC->getBody(); - if (Body) - L = Body->getBeginLoc(); - else - L = ADC->getDecl()->getEndLoc(); - break; - } - - L = UseEndOfStatement ? Parent->getEndLoc() : Parent->getBeginLoc(); - } while (!L.isValid()); - } - - // FIXME: Ironically, this assert actually fails in some cases. - //assert(L.isValid()); - return L; -} - -static PathDiagnosticLocation -getLocationForCaller(const StackFrameContext *SFC, - const LocationContext *CallerCtx, - const SourceManager &SM) { - const CFGBlock &Block = *SFC->getCallSiteBlock(); - CFGElement Source = Block[SFC->getIndex()]; - - switch (Source.getKind()) { - case CFGElement::Statement: - case CFGElement::Constructor: - case CFGElement::CXXRecordTypedCall: - return PathDiagnosticLocation(Source.castAs().getStmt(), - SM, CallerCtx); - case CFGElement::Initializer: { - const CFGInitializer &Init = Source.castAs(); - return PathDiagnosticLocation(Init.getInitializer()->getInit(), - SM, CallerCtx); - } - case CFGElement::AutomaticObjectDtor: { - const CFGAutomaticObjDtor &Dtor = Source.castAs(); - return PathDiagnosticLocation::createEnd(Dtor.getTriggerStmt(), - SM, CallerCtx); - } - case CFGElement::DeleteDtor: { - const CFGDeleteDtor &Dtor = Source.castAs(); - return PathDiagnosticLocation(Dtor.getDeleteExpr(), SM, CallerCtx); - } - case CFGElement::BaseDtor: - case CFGElement::MemberDtor: { - const AnalysisDeclContext *CallerInfo = CallerCtx->getAnalysisDeclContext(); - if (const Stmt *CallerBody = CallerInfo->getBody()) - return PathDiagnosticLocation::createEnd(CallerBody, SM, CallerCtx); - return PathDiagnosticLocation::create(CallerInfo->getDecl(), SM); - } - case CFGElement::NewAllocator: { - const CFGNewAllocator &Alloc = Source.castAs(); - return PathDiagnosticLocation(Alloc.getAllocatorExpr(), SM, CallerCtx); - } - case CFGElement::TemporaryDtor: { - // Temporary destructors are for temporaries. They die immediately at around - // the location of CXXBindTemporaryExpr. If they are lifetime-extended, - // they'd be dealt with via an AutomaticObjectDtor instead. - const auto &Dtor = Source.castAs(); - return PathDiagnosticLocation::createEnd(Dtor.getBindTemporaryExpr(), SM, - CallerCtx); - } - case CFGElement::ScopeBegin: - case CFGElement::ScopeEnd: - llvm_unreachable("not yet implemented!"); - case CFGElement::LifetimeEnds: - case CFGElement::LoopExit: - llvm_unreachable("CFGElement kind should not be on callsite!"); - } - - llvm_unreachable("Unknown CFGElement kind"); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createBegin(const Decl *D, - const SourceManager &SM) { - return PathDiagnosticLocation(D->getBeginLoc(), SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createBegin(const Stmt *S, - const SourceManager &SM, - LocationOrAnalysisDeclContext LAC) { - return PathDiagnosticLocation(getValidSourceLocation(S, LAC), - SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createEnd(const Stmt *S, - const SourceManager &SM, - LocationOrAnalysisDeclContext LAC) { - if (const auto *CS = dyn_cast(S)) - return createEndBrace(CS, SM); - return PathDiagnosticLocation(getValidSourceLocation(S, LAC, /*End=*/true), - SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO, - const SourceManager &SM) { - return PathDiagnosticLocation(BO->getOperatorLoc(), SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createConditionalColonLoc( - const ConditionalOperator *CO, - const SourceManager &SM) { - return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME, - const SourceManager &SM) { - - assert(ME->getMemberLoc().isValid() || ME->getBeginLoc().isValid()); - - // In some cases, getMemberLoc isn't valid -- in this case we'll return with - // some other related valid SourceLocation. - if (ME->getMemberLoc().isValid()) - return PathDiagnosticLocation(ME->getMemberLoc(), SM, SingleLocK); - - return PathDiagnosticLocation(ME->getBeginLoc(), SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS, - const SourceManager &SM) { - SourceLocation L = CS->getLBracLoc(); - return PathDiagnosticLocation(L, SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS, - const SourceManager &SM) { - SourceLocation L = CS->getRBracLoc(); - return PathDiagnosticLocation(L, SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createDeclBegin(const LocationContext *LC, - const SourceManager &SM) { - // FIXME: Should handle CXXTryStmt if analyser starts supporting C++. - if (const auto *CS = dyn_cast_or_null(LC->getDecl()->getBody())) - if (!CS->body_empty()) { - SourceLocation Loc = (*CS->body_begin())->getBeginLoc(); - return PathDiagnosticLocation(Loc, SM, SingleLocK); - } - - return PathDiagnosticLocation(); -} - -PathDiagnosticLocation -PathDiagnosticLocation::createDeclEnd(const LocationContext *LC, - const SourceManager &SM) { - SourceLocation L = LC->getDecl()->getBodyRBrace(); - return PathDiagnosticLocation(L, SM, SingleLocK); -} - -PathDiagnosticLocation -PathDiagnosticLocation::create(const ProgramPoint& P, - const SourceManager &SMng) { - const Stmt* S = nullptr; - if (Optional BE = P.getAs()) { - const CFGBlock *BSrc = BE->getSrc(); - if (BSrc->getTerminator().isVirtualBaseBranch()) { - // TODO: VirtualBaseBranches should also appear for destructors. - // In this case we should put the diagnostic at the end of decl. - return PathDiagnosticLocation::createBegin( - P.getLocationContext()->getDecl(), SMng); - - } else { - S = BSrc->getTerminatorCondition(); - if (!S) { - // If the BlockEdge has no terminator condition statement but its - // source is the entry of the CFG (e.g. a checker crated the branch at - // the beginning of a function), use the function's declaration instead. - assert(BSrc == &BSrc->getParent()->getEntry() && "CFGBlock has no " - "TerminatorCondition and is not the enrty block of the CFG"); - return PathDiagnosticLocation::createBegin( - P.getLocationContext()->getDecl(), SMng); - } - } - } else if (Optional SP = P.getAs()) { - S = SP->getStmt(); - if (P.getAs()) - return PathDiagnosticLocation::createEnd(S, SMng, P.getLocationContext()); - } else if (Optional PIP = P.getAs()) { - return PathDiagnosticLocation(PIP->getInitializer()->getSourceLocation(), - SMng); - } else if (Optional PIC = P.getAs()) { - return PathDiagnosticLocation(PIC->getLocation(), SMng); - } else if (Optional PIE = P.getAs()) { - return PathDiagnosticLocation(PIE->getLocation(), SMng); - } else if (Optional CE = P.getAs()) { - return getLocationForCaller(CE->getCalleeContext(), - CE->getLocationContext(), - SMng); - } else if (Optional CEE = P.getAs()) { - return getLocationForCaller(CEE->getCalleeContext(), - CEE->getLocationContext(), - SMng); - } else if (auto CEB = P.getAs()) { - if (const ReturnStmt *RS = CEB->getReturnStmt()) - return PathDiagnosticLocation::createBegin(RS, SMng, - CEB->getLocationContext()); - return PathDiagnosticLocation( - CEB->getLocationContext()->getDecl()->getSourceRange().getEnd(), SMng); - } else if (Optional BE = P.getAs()) { - CFGElement BlockFront = BE->getBlock()->front(); - if (auto StmtElt = BlockFront.getAs()) { - return PathDiagnosticLocation(StmtElt->getStmt()->getBeginLoc(), SMng); - } else if (auto NewAllocElt = BlockFront.getAs()) { - return PathDiagnosticLocation( - NewAllocElt->getAllocatorExpr()->getBeginLoc(), SMng); - } - llvm_unreachable("Unexpected CFG element at front of block"); - } else if (Optional FE = P.getAs()) { - return PathDiagnosticLocation(FE->getStmt(), SMng, - FE->getLocationContext()); - } else { - llvm_unreachable("Unexpected ProgramPoint"); - } - - return PathDiagnosticLocation(S, SMng, P.getLocationContext()); -} - -PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation( - const PathDiagnosticLocation &PDL) { - FullSourceLoc L = PDL.asLocation(); - return PathDiagnosticLocation(L, L.getManager(), SingleLocK); -} - -FullSourceLoc - PathDiagnosticLocation::genLocation(SourceLocation L, - LocationOrAnalysisDeclContext LAC) const { - assert(isValid()); - // Note that we want a 'switch' here so that the compiler can warn us in - // case we add more cases. - switch (K) { - case SingleLocK: - case RangeK: - break; - case StmtK: - // Defensive checking. - if (!S) - break; - return FullSourceLoc(getValidSourceLocation(S, LAC), - const_cast(*SM)); - case DeclK: - // Defensive checking. - if (!D) - break; - return FullSourceLoc(D->getLocation(), const_cast(*SM)); - } - - return FullSourceLoc(L, const_cast(*SM)); -} - -PathDiagnosticRange - PathDiagnosticLocation::genRange(LocationOrAnalysisDeclContext LAC) const { - assert(isValid()); - // Note that we want a 'switch' here so that the compiler can warn us in - // case we add more cases. - switch (K) { - case SingleLocK: - return PathDiagnosticRange(SourceRange(Loc,Loc), true); - case RangeK: - break; - case StmtK: { - const Stmt *S = asStmt(); - switch (S->getStmtClass()) { - default: - break; - case Stmt::DeclStmtClass: { - const auto *DS = cast(S); - if (DS->isSingleDecl()) { - // Should always be the case, but we'll be defensive. - return SourceRange(DS->getBeginLoc(), - DS->getSingleDecl()->getLocation()); - } - break; - } - // FIXME: Provide better range information for different - // terminators. - case Stmt::IfStmtClass: - case Stmt::WhileStmtClass: - case Stmt::DoStmtClass: - case Stmt::ForStmtClass: - case Stmt::ChooseExprClass: - case Stmt::IndirectGotoStmtClass: - case Stmt::SwitchStmtClass: - case Stmt::BinaryConditionalOperatorClass: - case Stmt::ConditionalOperatorClass: - case Stmt::ObjCForCollectionStmtClass: { - SourceLocation L = getValidSourceLocation(S, LAC); - return SourceRange(L, L); - } - } - SourceRange R = S->getSourceRange(); - if (R.isValid()) - return R; - break; - } - case DeclK: - if (const auto *MD = dyn_cast(D)) - return MD->getSourceRange(); - if (const auto *FD = dyn_cast(D)) { - if (Stmt *Body = FD->getBody()) - return Body->getSourceRange(); - } - else { - SourceLocation L = D->getLocation(); - return PathDiagnosticRange(SourceRange(L, L), true); - } - } - - return SourceRange(Loc, Loc); -} - -void PathDiagnosticLocation::flatten() { - if (K == StmtK) { - K = RangeK; - S = nullptr; - D = nullptr; - } - else if (K == DeclK) { - K = SingleLocK; - S = nullptr; - D = nullptr; - } -} - -//===----------------------------------------------------------------------===// -// Manipulation of PathDiagnosticCallPieces. -//===----------------------------------------------------------------------===// - -std::shared_ptr -PathDiagnosticCallPiece::construct(const CallExitEnd &CE, - const SourceManager &SM) { - const Decl *caller = CE.getLocationContext()->getDecl(); - PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(), - CE.getLocationContext(), - SM); - return std::shared_ptr( - new PathDiagnosticCallPiece(caller, pos)); -} - -PathDiagnosticCallPiece * -PathDiagnosticCallPiece::construct(PathPieces &path, - const Decl *caller) { - std::shared_ptr C( - new PathDiagnosticCallPiece(path, caller)); - path.clear(); - auto *R = C.get(); - path.push_front(std::move(C)); - return R; -} - -void PathDiagnosticCallPiece::setCallee(const CallEnter &CE, - const SourceManager &SM) { - const StackFrameContext *CalleeCtx = CE.getCalleeContext(); - Callee = CalleeCtx->getDecl(); - - callEnterWithin = PathDiagnosticLocation::createBegin(Callee, SM); - callEnter = getLocationForCaller(CalleeCtx, CE.getLocationContext(), SM); - - // Autosynthesized property accessors are special because we'd never - // pop back up to non-autosynthesized code until we leave them. - // This is not generally true for autosynthesized callees, which may call - // non-autosynthesized callbacks. - // Unless set here, the IsCalleeAnAutosynthesizedPropertyAccessor flag - // defaults to false. - if (const auto *MD = dyn_cast(Callee)) - IsCalleeAnAutosynthesizedPropertyAccessor = ( - MD->isPropertyAccessor() && - CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized()); -} - -static void describeTemplateParameters(raw_ostream &Out, - const ArrayRef TAList, - const LangOptions &LO, - StringRef Prefix = StringRef(), - StringRef Postfix = StringRef()); - -static void describeTemplateParameter(raw_ostream &Out, - const TemplateArgument &TArg, - const LangOptions &LO) { - - if (TArg.getKind() == TemplateArgument::ArgKind::Pack) { - describeTemplateParameters(Out, TArg.getPackAsArray(), LO); - } else { - TArg.print(PrintingPolicy(LO), Out); - } -} - -static void describeTemplateParameters(raw_ostream &Out, - const ArrayRef TAList, - const LangOptions &LO, - StringRef Prefix, StringRef Postfix) { - if (TAList.empty()) - return; - - Out << Prefix; - for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) { - describeTemplateParameter(Out, TAList[I], LO); - Out << ", "; - } - describeTemplateParameter(Out, TAList[TAList.size() - 1], LO); - Out << Postfix; -} - -static void describeClass(raw_ostream &Out, const CXXRecordDecl *D, - StringRef Prefix = StringRef()) { - if (!D->getIdentifier()) - return; - Out << Prefix << '\'' << *D; - if (const auto T = dyn_cast(D)) - describeTemplateParameters(Out, T->getTemplateArgs().asArray(), - D->getASTContext().getLangOpts(), "<", ">"); - - Out << '\''; -} - -static bool describeCodeDecl(raw_ostream &Out, const Decl *D, - bool ExtendedDescription, - StringRef Prefix = StringRef()) { - if (!D) - return false; - - if (isa(D)) { - if (ExtendedDescription) - Out << Prefix << "anonymous block"; - return ExtendedDescription; - } - - if (const auto *MD = dyn_cast(D)) { - Out << Prefix; - if (ExtendedDescription && !MD->isUserProvided()) { - if (MD->isExplicitlyDefaulted()) - Out << "defaulted "; - else - Out << "implicit "; - } - - if (const auto *CD = dyn_cast(MD)) { - if (CD->isDefaultConstructor()) - Out << "default "; - else if (CD->isCopyConstructor()) - Out << "copy "; - else if (CD->isMoveConstructor()) - Out << "move "; - - Out << "constructor"; - describeClass(Out, MD->getParent(), " for "); - } else if (isa(MD)) { - if (!MD->isUserProvided()) { - Out << "destructor"; - describeClass(Out, MD->getParent(), " for "); - } else { - // Use ~Foo for explicitly-written destructors. - Out << "'" << *MD << "'"; - } - } else if (MD->isCopyAssignmentOperator()) { - Out << "copy assignment operator"; - describeClass(Out, MD->getParent(), " for "); - } else if (MD->isMoveAssignmentOperator()) { - Out << "move assignment operator"; - describeClass(Out, MD->getParent(), " for "); - } else { - if (MD->getParent()->getIdentifier()) - Out << "'" << *MD->getParent() << "::" << *MD << "'"; - else - Out << "'" << *MD << "'"; - } - - return true; - } - - Out << Prefix << '\'' << cast(*D); - - // Adding template parameters. - if (const auto FD = dyn_cast(D)) - if (const TemplateArgumentList *TAList = - FD->getTemplateSpecializationArgs()) - describeTemplateParameters(Out, TAList->asArray(), - FD->getASTContext().getLangOpts(), "<", ">"); - - Out << '\''; - return true; -} - -std::shared_ptr -PathDiagnosticCallPiece::getCallEnterEvent() const { - // We do not produce call enters and call exits for autosynthesized property - // accessors. We do generally produce them for other functions coming from - // the body farm because they may call callbacks that bring us back into - // visible code. - if (!Callee || IsCalleeAnAutosynthesizedPropertyAccessor) - return nullptr; - - SmallString<256> buf; - llvm::raw_svector_ostream Out(buf); - - Out << "Calling "; - describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true); - - assert(callEnter.asLocation().isValid()); - return std::make_shared(callEnter, Out.str()); -} - -std::shared_ptr -PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const { - if (!callEnterWithin.asLocation().isValid()) - return nullptr; - if (Callee->isImplicit() || !Callee->hasBody()) - return nullptr; - if (const auto *MD = dyn_cast(Callee)) - if (MD->isDefaulted()) - return nullptr; - - SmallString<256> buf; - llvm::raw_svector_ostream Out(buf); - - Out << "Entered call"; - describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from "); - - return std::make_shared(callEnterWithin, Out.str()); -} - -std::shared_ptr -PathDiagnosticCallPiece::getCallExitEvent() const { - // We do not produce call enters and call exits for autosynthesized property - // accessors. We do generally produce them for other functions coming from - // the body farm because they may call callbacks that bring us back into - // visible code. - if (NoExit || IsCalleeAnAutosynthesizedPropertyAccessor) - return nullptr; - - SmallString<256> buf; - llvm::raw_svector_ostream Out(buf); - - if (!CallStackMessage.empty()) { - Out << CallStackMessage; - } else { - bool DidDescribe = describeCodeDecl(Out, Callee, - /*ExtendedDescription=*/false, - "Returning from "); - if (!DidDescribe) - Out << "Returning to caller"; - } - - assert(callReturn.asLocation().isValid()); - return std::make_shared(callReturn, Out.str()); -} - -static void compute_path_size(const PathPieces &pieces, unsigned &size) { - for (const auto &I : pieces) { - const PathDiagnosticPiece *piece = I.get(); - if (const auto *cp = dyn_cast(piece)) - compute_path_size(cp->path, size); - else - ++size; - } -} - -unsigned PathDiagnostic::full_size() { - unsigned size = 0; - compute_path_size(path, size); - return size; -} - -//===----------------------------------------------------------------------===// -// FoldingSet profiling methods. -//===----------------------------------------------------------------------===// - -void PathDiagnosticLocation::Profile(llvm::FoldingSetNodeID &ID) const { - ID.AddInteger(Range.getBegin().getRawEncoding()); - ID.AddInteger(Range.getEnd().getRawEncoding()); - ID.AddInteger(Loc.getRawEncoding()); -} - -void PathDiagnosticPiece::Profile(llvm::FoldingSetNodeID &ID) const { - ID.AddInteger((unsigned) getKind()); - ID.AddString(str); - // FIXME: Add profiling support for code hints. - ID.AddInteger((unsigned) getDisplayHint()); - ArrayRef Ranges = getRanges(); - for (const auto &I : Ranges) { - ID.AddInteger(I.getBegin().getRawEncoding()); - ID.AddInteger(I.getEnd().getRawEncoding()); - } -} - -void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticPiece::Profile(ID); - for (const auto &I : path) - ID.Add(*I); -} - -void PathDiagnosticSpotPiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticPiece::Profile(ID); - ID.Add(Pos); -} - -void PathDiagnosticControlFlowPiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticPiece::Profile(ID); - for (const auto &I : *this) - ID.Add(I); -} - -void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticSpotPiece::Profile(ID); - for (const auto &I : subPieces) - ID.Add(*I); -} - -void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticSpotPiece::Profile(ID); -} - -void PathDiagnosticPopUpPiece::Profile(llvm::FoldingSetNodeID &ID) const { - PathDiagnosticSpotPiece::Profile(ID); -} - -void PathDiagnostic::Profile(llvm::FoldingSetNodeID &ID) const { - ID.Add(getLocation()); - ID.AddString(BugType); - ID.AddString(VerboseDesc); - ID.AddString(Category); -} - -void PathDiagnostic::FullProfile(llvm::FoldingSetNodeID &ID) const { - Profile(ID); - for (const auto &I : path) - ID.Add(*I); - for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I) - ID.AddString(*I); -} - -LLVM_DUMP_METHOD void PathPieces::dump() const { - unsigned index = 0; - for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) { - llvm::errs() << "[" << index++ << "] "; - (*I)->dump(); - llvm::errs() << "\n"; - } -} - -LLVM_DUMP_METHOD void PathDiagnosticCallPiece::dump() const { - llvm::errs() << "CALL\n--------------\n"; - - if (const Stmt *SLoc = getLocation().getStmtOrNull()) - SLoc->dump(); - else if (const auto *ND = dyn_cast_or_null(getCallee())) - llvm::errs() << *ND << "\n"; - else - getLocation().dump(); -} - -LLVM_DUMP_METHOD void PathDiagnosticEventPiece::dump() const { - llvm::errs() << "EVENT\n--------------\n"; - llvm::errs() << getString() << "\n"; - llvm::errs() << " ---- at ----\n"; - getLocation().dump(); -} - -LLVM_DUMP_METHOD void PathDiagnosticControlFlowPiece::dump() const { - llvm::errs() << "CONTROL\n--------------\n"; - getStartLocation().dump(); - llvm::errs() << " ---- to ----\n"; - getEndLocation().dump(); -} - -LLVM_DUMP_METHOD void PathDiagnosticMacroPiece::dump() const { - llvm::errs() << "MACRO\n--------------\n"; - // FIXME: Print which macro is being invoked. -} - -LLVM_DUMP_METHOD void PathDiagnosticNotePiece::dump() const { - llvm::errs() << "NOTE\n--------------\n"; - llvm::errs() << getString() << "\n"; - llvm::errs() << " ---- at ----\n"; - getLocation().dump(); -} - -LLVM_DUMP_METHOD void PathDiagnosticPopUpPiece::dump() const { - llvm::errs() << "POP-UP\n--------------\n"; - llvm::errs() << getString() << "\n"; - llvm::errs() << " ---- at ----\n"; - getLocation().dump(); -} - -LLVM_DUMP_METHOD void PathDiagnosticLocation::dump() const { - if (!isValid()) { - llvm::errs() << "\n"; - return; - } - - switch (K) { - case RangeK: - // FIXME: actually print the range. - llvm::errs() << "\n"; - break; - case SingleLocK: - asLocation().dump(); - llvm::errs() << "\n"; - break; - case StmtK: - if (S) - S->dump(); - else - llvm::errs() << "\n"; - break; - case DeclK: - if (const auto *ND = dyn_cast_or_null(D)) - llvm::errs() << *ND << "\n"; - else if (isa(D)) - // FIXME: Make this nicer. - llvm::errs() << "\n"; - else if (D) - llvm::errs() << "\n"; - else - llvm::errs() << "\n"; - break; - } -} Index: cfe/trunk/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/PlistSupport.h" #include "clang/Basic/SourceManager.h" @@ -20,7 +21,6 @@ #include "clang/Lex/TokenConcatenation.h" #include "clang/Rewrite/Core/HTMLRewrite.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/IssueHash.h" #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" #include "llvm/ADT/SmallPtrSet.h" Index: cfe/trunk/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp +++ cfe/trunk/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp @@ -10,10 +10,10 @@ // //===----------------------------------------------------------------------===// +#include "clang/Analysis/PathDiagnostic.h" #include "clang/Basic/Version.h" #include "clang/Lex/Preprocessor.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringMap.h" Index: cfe/trunk/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp =================================================================== --- cfe/trunk/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp +++ cfe/trunk/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp @@ -12,6 +12,7 @@ #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h" #include "ModelInjector.h" +#include "clang/Analysis/PathDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" @@ -27,7 +28,6 @@ #include "clang/StaticAnalyzer/Checkers/LocalCheckers.h" #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h" #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h" #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" Index: clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp =================================================================== --- clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp +++ clang-tools-extra/trunk/clang-tidy/ClangTidy.cpp @@ -36,10 +36,6 @@ #include "clang/Rewrite/Frontend/FixItRewriter.h" #include "clang/Rewrite/Frontend/FrontendActions.h" #include "clang/Tooling/Core/Diagnostic.h" -#if CLANG_ENABLE_STATIC_ANALYZER -#include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" -#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h" -#endif // CLANG_ENABLE_STATIC_ANALYZER #include "clang/Tooling/DiagnosticsYaml.h" #include "clang/Tooling/Refactoring.h" #include "clang/Tooling/ReplacementsYaml.h" @@ -49,6 +45,11 @@ #include #include +#if CLANG_ENABLE_STATIC_ANALYZER +#include "clang/Analysis/PathDiagnostic.h" +#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h" +#endif // CLANG_ENABLE_STATIC_ANALYZER + using namespace clang::ast_matchers; using namespace clang::driver; using namespace clang::tooling;