head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.12 netbsd-11-0-RC3:1.1.1.12 netbsd-11-0-RC2:1.1.1.12 netbsd-11-0-RC1:1.1.1.12 perseant-exfatfs-base-20250801:1.1.1.12 netbsd-11:1.1.1.12.0.10 netbsd-11-base:1.1.1.12 netbsd-10-1-RELEASE:1.1.1.12 perseant-exfatfs-base-20240630:1.1.1.12 perseant-exfatfs:1.1.1.12.0.8 perseant-exfatfs-base:1.1.1.12 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.11 netbsd-10-0-RELEASE:1.1.1.12 netbsd-10-0-RC6:1.1.1.12 netbsd-10-0-RC5:1.1.1.12 netbsd-10-0-RC4:1.1.1.12 netbsd-10-0-RC3:1.1.1.12 netbsd-10-0-RC2:1.1.1.12 netbsd-10-0-RC1:1.1.1.12 netbsd-10:1.1.1.12.0.6 netbsd-10-base:1.1.1.12 netbsd-9-3-RELEASE:1.1.1.11 cjep_sun2x:1.1.1.12.0.4 cjep_sun2x-base:1.1.1.12 cjep_staticlib_x-base1:1.1.1.12 netbsd-9-2-RELEASE:1.1.1.11 cjep_staticlib_x:1.1.1.12.0.2 cjep_staticlib_x-base:1.1.1.12 netbsd-9-1-RELEASE:1.1.1.11 phil-wifi-20200421:1.1.1.12 phil-wifi-20200411:1.1.1.12 phil-wifi-20200406:1.1.1.12 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.11 netbsd-9-0-RC2:1.1.1.11 netbsd-9-0-RC1:1.1.1.11 netbsd-9:1.1.1.11.0.2 netbsd-9-base:1.1.1.11 phil-wifi-20190609:1.1.1.11 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.10.2.1 pgoyette-compat-20190127:1.1.1.11 pgoyette-compat-20190118:1.1.1.11 pgoyette-compat-1226:1.1.1.11 pgoyette-compat-1126:1.1.1.11 pgoyette-compat-1020:1.1.1.11 pgoyette-compat-0930:1.1.1.11 pgoyette-compat-0906:1.1.1.11 netbsd-7-2-RELEASE:1.1.1.6.2.1 pgoyette-compat-0728:1.1.1.11 clang-337282:1.1.1.11 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.10.0.4 phil-wifi-base:1.1.1.10 pgoyette-compat-0625:1.1.1.10 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.10 pgoyette-compat-0502:1.1.1.10 pgoyette-compat-0422:1.1.1.10 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.10 pgoyette-compat-0407:1.1.1.10 pgoyette-compat-0330:1.1.1.10 pgoyette-compat-0322:1.1.1.10 pgoyette-compat-0315:1.1.1.10 netbsd-7-1-2-RELEASE:1.1.1.6.2.1 pgoyette-compat:1.1.1.10.0.2 pgoyette-compat-base:1.1.1.10 netbsd-7-1-1-RELEASE:1.1.1.6.2.1 clang-319952:1.1.1.10 matt-nb8-mediatek:1.1.1.9.0.10 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.10 perseant-stdc-iso10646:1.1.1.9.0.8 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.6 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.4 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.6.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.6.2.1 netbsd-7-1-RC2:1.1.1.6.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.6.2.1 bouyer-socketcan:1.1.1.9.0.2 bouyer-socketcan-base:1.1.1.9 clang-291444:1.1.1.9 pgoyette-localcount-20170107:1.1.1.8 netbsd-7-1-RC1:1.1.1.6.2.1 pgoyette-localcount-20161104:1.1.1.8 netbsd-7-0-2-RELEASE:1.1.1.6.2.1 localcount-20160914:1.1.1.8 netbsd-7-nhusb:1.1.1.6.2.1.0.4 netbsd-7-nhusb-base:1.1.1.6.2.1 clang-280599:1.1.1.8 pgoyette-localcount-20160806:1.1.1.8 pgoyette-localcount-20160726:1.1.1.8 pgoyette-localcount:1.1.1.8.0.2 pgoyette-localcount-base:1.1.1.8 netbsd-7-0-1-RELEASE:1.1.1.6.2.1 clang-261930:1.1.1.8 netbsd-7-0:1.1.1.6.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.6.2.1 netbsd-7-0-RC3:1.1.1.6.2.1 netbsd-7-0-RC2:1.1.1.6.2.1 netbsd-7-0-RC1:1.1.1.6.2.1 clang-237755:1.1.1.7 clang-232565:1.1.1.7 clang-227398:1.1.1.7 tls-maxphys-base:1.1.1.6 tls-maxphys:1.1.1.6.0.4 netbsd-7:1.1.1.6.0.2 netbsd-7-base:1.1.1.6 clang-215315:1.1.1.6 clang-209886:1.1.1.5 yamt-pagecache:1.1.1.4.0.4 yamt-pagecache-base9:1.1.1.4 tls-earlyentropy:1.1.1.4.0.2 tls-earlyentropy-base:1.1.1.5 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.4 riastradh-drm2-base3:1.1.1.4 clang-202566:1.1.1.4 clang-201163:1.1.1.3 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.35; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.25; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.03.04.19.55.04; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid 29z1hJonZISIXprx; 1.1.1.5 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.6; commitid 8q0kdlBlCn09GACx; 1.1.1.6 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.6.2.1 1.1.1.6.4.1; next 1.1.1.7; commitid N85tXAN6Ex9VZPLx; 1.1.1.7 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.8; commitid mlISSizlPKvepX7y; 1.1.1.8 date 2016.02.27.22.12.06; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid tIimz3oDlh1NpBWy; 1.1.1.9 date 2017.01.11.10.35.32; author joerg; state Exp; branches; next 1.1.1.10; commitid CNnUNfII1jgNmxBz; 1.1.1.10 date 2017.08.01.19.35.14; author joerg; state Exp; branches 1.1.1.10.2.1 1.1.1.10.4.1; next 1.1.1.11; commitid pMuDy65V0VicSx1A; 1.1.1.11 date 2018.07.17.18.31.06; author joerg; state Exp; branches; next 1.1.1.12; commitid wDzL46ALjrCZgwKA; 1.1.1.12 date 2019.11.13.22.19.29; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.4.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.4.4.1 date 2014.03.04.19.55.04; author yamt; state dead; branches; next 1.1.1.4.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.4.2 date 2014.05.22.16.18.31; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.6.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.6.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.6.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.4.2 date 2014.08.19.23.47.32; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.8.2.1 date 2017.03.20.06.52.42; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2018.07.28.04.33.24; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.10.4.1 date 2019.06.10.21.45.29; author christos; state Exp; branches; next 1.1.1.10.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.10.4.2 date 2020.04.13.07.46.39; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the PathDiagnostic-related interfaces. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ParentMap.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; bool PathDiagnosticMacroPiece::containsEvent() const { for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I!=E; ++I) { if (isa(*I)) return true; if (PathDiagnosticMacroPiece *MP = dyn_cast(*I)) if (MP->containsEvent()) return true; } return false; } 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), LastInMainSourceFile(false) {} PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint) : kind(k), Hint(hint), LastInMainSourceFile(false) {} PathDiagnosticPiece::~PathDiagnosticPiece() {} PathDiagnosticEventPiece::~PathDiagnosticEventPiece() {} PathDiagnosticCallPiece::~PathDiagnosticCallPiece() {} PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() {} PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() {} PathPieces::~PathPieces() {} void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current, bool ShouldFlattenMacros) const { for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) { PathDiagnosticPiece *Piece = I->getPtr(); switch (Piece->getKind()) { case PathDiagnosticPiece::Call: { PathDiagnosticCallPiece *Call = cast(Piece); IntrusiveRefCntPtr CallEnter = Call->getCallEnterEvent(); if (CallEnter) Current.push_back(CallEnter); Call->path.flattenTo(Primary, Primary, ShouldFlattenMacros); IntrusiveRefCntPtr callExit = Call->getCallExitEvent(); if (callExit) Current.push_back(callExit); break; } case PathDiagnosticPiece::Macro: { PathDiagnosticMacroPiece *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: Current.push_back(Piece); break; } } } PathDiagnostic::~PathDiagnostic() {} PathDiagnostic::PathDiagnostic(const Decl *declWithIssue, StringRef bugtype, StringRef verboseDesc, StringRef shortDesc, StringRef category, PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique) : DeclWithIssue(declWithIssue), BugType(StripTrailingDots(bugtype)), VerboseDesc(StripTrailingDots(verboseDesc)), ShortDesc(StripTrailingDots(shortDesc)), Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique), UniqueingDecl(DeclToUnique), path(pathImpl) {} static PathDiagnosticCallPiece * getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP, const SourceManager &SMgr) { SourceLocation CallLoc = CP->callEnter.asLocation(); // If the call is within a macro, don't do anything (for now). if (CallLoc.isMacroID()) return 0; assert(SMgr.isInMainFile(CallLoc) && "The call piece should be in the main file."); // Check if CP represents a path through a function outside of the main file. if (!SMgr.isInMainFile(CP->callEnterWithin.asLocation())) return CP; const PathPieces &Path = CP->path; if (Path.empty()) return 0; // Check if the last piece in the callee path is a call to a function outside // of the main file. if (PathDiagnosticCallPiece *CPInner = dyn_cast(Path.back())) { return getFirstStackedCallToHeaderFile(CPInner, SMgr); } // Otherwise, the last piece is in the main file. return 0; } void PathDiagnostic::resetDiagnosticLocationToMainFile() { if (path.empty()) return; PathDiagnosticPiece *LastP = path.back().getPtr(); assert(LastP); const SourceManager &SMgr = LastP->getLocation().getManager(); // We only need to check if the report ends inside headers, if the last piece // is a call piece. if (PathDiagnosticCallPiece *CP = dyn_cast(LastP)) { CP = getFirstStackedCallToHeaderFile(CP, SMgr); if (CP) { // Mark the piece. CP->setAsLastInMainSourceFile(); // Update the path diagnostic message. const NamedDecl *ND = dyn_cast(CP->getCallee()); if (ND) { SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << " (within a call to '" << ND->getDeclName() << "')"; appendToDesc(os.str()); } // Reset the report containing declaration and location. DeclWithIssue = CP->getCaller(); Loc = CP->getLocation(); return; } } } void PathDiagnosticConsumer::anchor() { } PathDiagnosticConsumer::~PathDiagnosticConsumer() { // Delete the contents of the FoldingSet if it isn't empty already. for (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end() ; it != et ; ++it) { delete &*it; } } void PathDiagnosticConsumer::HandlePathDiagnostic(PathDiagnostic *D) { OwningPtr OwningD(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.begin())->getLocation().getManager(); SmallVector WorkList; WorkList.push_back(&D->path); while (!WorkList.empty()) { const PathPieces &path = *WorkList.pop_back_val(); for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) { const PathDiagnosticPiece *piece = I->getPtr(); FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc(); if (FID.isInvalid()) { FID = SMgr.getFileID(L); } else if (SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? // Check the source ranges. ArrayRef Ranges = piece->getRanges(); for (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { SourceLocation L = SMgr.getExpansionLoc(I->getBegin()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? L = SMgr.getExpansionLoc(I->getEnd()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? } if (const PathDiagnosticCallPiece *call = dyn_cast(piece)) { WorkList.push_back(&call->path); } else if (const PathDiagnosticMacroPiece *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 = 0; 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); Diags.RemoveNode(orig); delete orig; } Diags.InsertNode(OwningD.take()); } 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 clang::ento::PathDiagnosticPiece::ControlFlow: return compareControlFlow(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Event: return None; case clang::ento::PathDiagnosticPiece::Macro: return compareMacro(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Call: return compareCall(cast(X), cast(Y)); } 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 compare(const PathDiagnostic &X, const PathDiagnostic &Y) { FullSourceLoc XL = X.getLocation().asLocation(); FullSourceLoc YL = Y.getLocation().asLocation(); if (XL != YL) return XL.isBeforeInTranslationUnitThan(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 SM.isBeforeInTranslationUnit(XDL, YDL); } } 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(); } namespace { struct CompareDiagnostics { // Compare if 'X' is "<" than 'Y'. bool operator()(const PathDiagnostic *X, const PathDiagnostic *Y) const { if (X == Y) return false; return compare(*X, *Y); } }; } void PathDiagnosticConsumer::FlushDiagnostics( PathDiagnosticConsumer::FilesMade *Files) { if (flushed) return; flushed = true; std::vector BatchDiags; for (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end(); it != et; ++it) { const PathDiagnostic *D = &*it; BatchDiags.push_back(D); } // Sort the diagnostics so that they are always emitted in a deterministic // order. if (!BatchDiags.empty()) std::sort(BatchDiags.begin(), BatchDiags.end(), CompareDiagnostics()); FlushDiagnosticsImpl(BatchDiags, Files); // Delete the flushed diagnostics. for (std::vector::iterator it = BatchDiags.begin(), et = BatchDiags.end(); it != et; ++it) { const PathDiagnostic *D = *it; delete D; } // Clear out the FoldingSet. Diags.clear(); } void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, StringRef ConsumerName, StringRef FileName) { llvm::FoldingSetNodeID NodeID; NodeID.Add(PD); void *InsertPos; PDFileEntry *Entry = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) { Entry = Alloc.Allocate(); Entry = new (Entry) PDFileEntry(NodeID); 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 = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) return 0; return &Entry->files; } //===----------------------------------------------------------------------===// // PathDiagnosticLocation methods. //===----------------------------------------------------------------------===// static SourceLocation getValidSourceLocation(const Stmt* S, LocationOrAnalysisDeclContext LAC, bool UseEnd = false) { SourceLocation L = UseEnd ? S->getLocEnd() : S->getLocStart(); 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->getLocStart(); else L = ADC->getDecl()->getLocEnd(); break; } L = UseEnd ? Parent->getLocEnd() : Parent->getLocStart(); } while (!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: 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::TemporaryDtor: llvm_unreachable("not yet implemented!"); } llvm_unreachable("Unknown CFGElement kind"); } PathDiagnosticLocation PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) { return PathDiagnosticLocation(D->getLocStart(), 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 CompoundStmt *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::createMemberLoc(const MemberExpr *ME, const SourceManager &SM) { return PathDiagnosticLocation(ME->getMemberLoc(), 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 CompoundStmt *CS = dyn_cast_or_null(LC->getDecl()->getBody())) if (!CS->body_empty()) { SourceLocation Loc = (*CS->body_begin())->getLocStart(); 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 = 0; if (Optional BE = P.getAs()) { const CFGBlock *BSrc = BE->getSrc(); S = BSrc->getTerminatorCondition(); } 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 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 { llvm_unreachable("Unexpected ProgramPoint"); } return PathDiagnosticLocation(S, SMng, P.getLocationContext()); } const Stmt *PathDiagnosticLocation::getStmt(const ExplodedNode *N) { ProgramPoint P = N->getLocation(); if (Optional SP = P.getAs()) return SP->getStmt(); if (Optional BE = P.getAs()) return BE->getSrc()->getTerminator(); if (Optional CE = P.getAs()) return CE->getCallExpr(); if (Optional CEE = P.getAs()) return CEE->getCalleeContext()->getCallSite(); if (Optional PIPP = P.getAs()) return PIPP->getInitializer()->getInit(); return 0; } const Stmt *PathDiagnosticLocation::getNextStmt(const ExplodedNode *N) { for (N = N->getFirstSucc(); N; N = N->getFirstSucc()) { if (const Stmt *S = getStmt(N)) { // Check if the statement is '?' or '&&'/'||'. These are "merges", // not actual statement points. switch (S->getStmtClass()) { case Stmt::ChooseExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::ConditionalOperatorClass: continue; case Stmt::BinaryOperatorClass: { BinaryOperatorKind Op = cast(S)->getOpcode(); if (Op == BO_LAnd || Op == BO_LOr) continue; break; } default: break; } // We found the statement, so return it. return S; } } return 0; } PathDiagnosticLocation PathDiagnosticLocation::createEndOfPath(const ExplodedNode *N, const SourceManager &SM) { assert(N && "Cannot create a location with a null node."); const Stmt *S = getStmt(N); if (!S) S = getNextStmt(N); if (S) { ProgramPoint P = N->getLocation(); const LocationContext *LC = N->getLocationContext(); // For member expressions, return the location of the '.' or '->'. if (const MemberExpr *ME = dyn_cast(S)) return PathDiagnosticLocation::createMemberLoc(ME, SM); // For binary operators, return the location of the operator. if (const BinaryOperator *B = dyn_cast(S)) return PathDiagnosticLocation::createOperatorLoc(B, SM); if (P.getAs()) return PathDiagnosticLocation::createEnd(S, SM, LC); if (S->getLocStart().isValid()) return PathDiagnosticLocation(S, SM, LC); return PathDiagnosticLocation(getValidSourceLocation(S, LC), SM); } return createDeclEnd(N->getLocationContext(), SM); } 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 DeclStmt *DS = cast(S); if (DS->isSingleDecl()) { // Should always be the case, but we'll be defensive. return SourceRange(DS->getLocStart(), 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 ObjCMethodDecl *MD = dyn_cast(D)) return MD->getSourceRange(); if (const FunctionDecl *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 = 0; D = 0; } else if (K == DeclK) { K = SingleLocK; S = 0; D = 0; } } //===----------------------------------------------------------------------===// // Manipulation of PathDiagnosticCallPieces. //===----------------------------------------------------------------------===// PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(const ExplodedNode *N, const CallExitEnd &CE, const SourceManager &SM) { const Decl *caller = CE.getLocationContext()->getDecl(); PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(), CE.getLocationContext(), SM); return new PathDiagnosticCallPiece(caller, pos); } PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(PathPieces &path, const Decl *caller) { PathDiagnosticCallPiece *C = new PathDiagnosticCallPiece(path, caller); path.clear(); path.push_front(C); return C; } 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); } static inline void describeClass(raw_ostream &Out, const CXXRecordDecl *D, StringRef Prefix = StringRef()) { if (!D->getIdentifier()) return; Out << Prefix << '\'' << *D << '\''; } 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 CXXMethodDecl *MD = dyn_cast(D)) { Out << Prefix; if (ExtendedDescription && !MD->isUserProvided()) { if (MD->isExplicitlyDefaulted()) Out << "defaulted "; else Out << "implicit "; } if (const CXXConstructorDecl *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) << '\''; return true; } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterEvent() const { if (!Callee) return 0; SmallString<256> buf; llvm::raw_svector_ostream Out(buf); Out << "Calling "; describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true); assert(callEnter.asLocation().isValid()); return new PathDiagnosticEventPiece(callEnter, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const { if (!callEnterWithin.asLocation().isValid()) return 0; if (Callee->isImplicit() || !Callee->hasBody()) return 0; if (const CXXMethodDecl *MD = dyn_cast(Callee)) if (MD->isDefaulted()) return 0; SmallString<256> buf; llvm::raw_svector_ostream Out(buf); Out << "Entered call"; describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from "); return new PathDiagnosticEventPiece(callEnterWithin, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallExitEvent() const { if (NoExit) return 0; 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 new PathDiagnosticEventPiece(callReturn, Out.str()); } static void compute_path_size(const PathPieces &pieces, unsigned &size) { for (PathPieces::const_iterator it = pieces.begin(), et = pieces.end(); it != et; ++it) { const PathDiagnosticPiece *piece = it->getPtr(); if (const PathDiagnosticCallPiece *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()); return; } 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 (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { ID.AddInteger(I->getBegin().getRawEncoding()); ID.AddInteger(I->getEnd().getRawEncoding()); } } void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticPiece::Profile(ID); for (PathPieces::const_iterator it = path.begin(), et = path.end(); it != et; ++it) { ID.Add(**it); } } 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_iterator I = begin(), E = end(); I != E; ++I) ID.Add(*I); } void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticSpotPiece::Profile(ID); for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I != E; ++I) ID.Add(**I); } 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 (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) ID.Add(**I); for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I) ID.AddString(*I); } StackHintGenerator::~StackHintGenerator() {} std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){ ProgramPoint P = N->getLocation(); CallExitEnd CExit = P.castAs(); // FIXME: Use CallEvent to abstract this over all calls. const Stmt *CallSite = CExit.getCalleeContext()->getCallSite(); const CallExpr *CE = dyn_cast_or_null(CallSite); if (!CE) return ""; if (!N) return getMessageForSymbolNotFound(); // Check if one of the parameters are set to the interesting symbol. ProgramStateRef State = N->getState(); const LocationContext *LCtx = N->getLocationContext(); unsigned ArgIndex = 0; for (CallExpr::const_arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I, ++ArgIndex){ SVal SV = State->getSVal(*I, LCtx); // Check if the variable corresponding to the symbol is passed by value. SymbolRef AS = SV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } // Check if the parameter is a pointer to the symbol. if (Optional Reg = SV.getAs()) { SVal PSV = State->getSVal(Reg->getRegion()); SymbolRef AS = PSV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } } } // Check if we are returning the interesting symbol. SVal SV = State->getSVal(CE, LCtx); SymbolRef RetSym = SV.getAsLocSymbol(); if (RetSym == Sym) { return getMessageForReturn(CE); } return getMessageForSymbolNotFound(); } std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE, unsigned ArgIndex) { // Printed parameters start at 1, not 0. ++ArgIndex; SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << Msg << " via " << ArgIndex << llvm::getOrdinalSuffix(ArgIndex) << " parameter"; return os.str(); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @a612 8 PathDiagnosticLocation::createConditionalColonLoc( const ConditionalOperator *CO, const SourceManager &SM) { return PathDiagnosticLocation(CO->getColonLoc(), SM, SingleLocK); } PathDiagnosticLocation @ 1.1.1.3 log @Import Clang 3.5svn r199312 @ text @a573 1 case CFGElement::NewAllocator: d742 1 a742 4 if (!S) { // If this is an implicit call, return the implicit call point location. if (Optional PIE = N->getLocationAs()) return PathDiagnosticLocation(PIE->getLocation(), SM); a743 1 } @ 1.1.1.4 log @Import Clang 3.5svn r202566. @ text @d109 1 a109 1 PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue, d114 1 a114 2 : CheckName(CheckName), DeclWithIssue(declWithIssue), @ 1.1.1.4.2.1 log @Rebase. @ text @a18 1 #include "clang/AST/ExprCXX.h" d131 1 a131 1 return nullptr; d142 1 a142 1 return nullptr; d152 1 a152 1 return nullptr; d200 2 a201 2 std::unique_ptr OwningD(D); d262 1 a262 1 void *InsertPos = nullptr; d278 2 a279 2 Diags.InsertNode(OwningD.release()); d419 11 d447 2 a448 5 std::sort(BatchDiags.begin(), BatchDiags.end(), [](const PathDiagnostic *X, const PathDiagnostic *Y) { return X != Y && compare(*X, *Y); }); a461 5 PathDiagnosticConsumer::FilesMade::~FilesMade() { for (PDFileEntry &Entry : *this) Entry.~PDFileEntry(); } d491 1 a491 1 return nullptr; d667 1 a667 1 const Stmt* S = nullptr; d708 1 a708 1 return nullptr; d735 1 a735 1 return nullptr; d870 2 a871 2 S = nullptr; D = nullptr; d875 2 a876 2 S = nullptr; D = nullptr; d986 1 a986 1 return nullptr; d1001 1 a1001 1 return nullptr; d1003 1 a1003 1 return nullptr; d1006 1 a1006 1 return nullptr; d1020 1 a1020 1 return nullptr; @ 1.1.1.5 log @Import Clang 3.5svn r209886. @ text @a18 1 #include "clang/AST/ExprCXX.h" d131 1 a131 1 return nullptr; d142 1 a142 1 return nullptr; d152 1 a152 1 return nullptr; d200 2 a201 2 std::unique_ptr OwningD(D); d262 1 a262 1 void *InsertPos = nullptr; d278 2 a279 2 Diags.InsertNode(OwningD.release()); d419 11 d447 2 a448 5 std::sort(BatchDiags.begin(), BatchDiags.end(), [](const PathDiagnostic *X, const PathDiagnostic *Y) { return X != Y && compare(*X, *Y); }); a461 5 PathDiagnosticConsumer::FilesMade::~FilesMade() { for (PDFileEntry &Entry : *this) Entry.~PDFileEntry(); } d491 1 a491 1 return nullptr; d667 1 a667 1 const Stmt* S = nullptr; d708 1 a708 1 return nullptr; d735 1 a735 1 return nullptr; d870 2 a871 2 S = nullptr; D = nullptr; d875 2 a876 2 S = nullptr; D = nullptr; d986 1 a986 1 return nullptr; d1001 1 a1001 1 return nullptr; d1003 1 a1003 1 return nullptr; d1006 1 a1006 1 return nullptr; d1020 1 a1020 1 return nullptr; @ 1.1.1.6 log @Import clang 3.6svn r215315. @ text @d70 1 a70 1 PathDiagnosticPiece *Piece = I->get(); d160 1 a160 1 PathDiagnosticPiece *LastP = path.back().get(); d225 1 a225 1 const PathDiagnosticPiece *piece = I->get(); d1040 1 a1040 1 const PathDiagnosticPiece *piece = it->get(); @ 1.1.1.6.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d200 3 a202 2 void PathDiagnosticConsumer::HandlePathDiagnostic( std::unique_ptr D) { d216 1 a216 1 const SourceManager &SMgr = D->path.front()->getLocation().getManager(); d275 1 a275 1 assert(orig != D.get()); d280 1 a280 1 Diags.InsertNode(D.release()); @ 1.1.1.7 log @Import Clang 3.6RC1 r227398. @ text @d200 3 a202 2 void PathDiagnosticConsumer::HandlePathDiagnostic( std::unique_ptr D) { d216 1 a216 1 const SourceManager &SMgr = D->path.front()->getLocation().getManager(); d275 1 a275 1 assert(orig != D.get()); d280 1 a280 1 Diags.InsertNode(D.release()); @ 1.1.1.8 log @Import Clang 3.8.0rc3 r261930. @ text @d65 2 d184 1 a184 1 d204 1 a204 1 d226 1 a226 1 d231 1 a231 1 d243 1 a243 1 d254 1 a254 1 d257 1 a257 1 } d323 1 a323 1 d336 1 a336 1 d346 1 a346 1 d423 1 a423 1 d425 1 a425 1 d435 5 a439 9 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); d449 1 a449 1 d455 1 a455 1 for (PDFileEntry &Entry : Set) d465 1 a465 1 PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); d469 1 a469 1 Set.InsertNode(Entry, InsertPos); d471 1 a471 1 d486 1 a486 1 PDFileEntry *Entry = Set.FindNodeOrInsertPos(NodeID, InsertPos); d846 1 a846 1 break; d948 1 a948 1 d1040 1 a1040 1 if (const PathDiagnosticCallPiece *cp = d1076 1 a1076 1 } d1081 1 a1081 1 for (PathPieces::const_iterator it = path.begin(), @ 1.1.1.8.2.1 log @Sync with HEAD @ text @d32 3 a34 2 for (auto &P : subPieces) { if (isa(*P)) d36 1 a36 1 if (auto *MP = dyn_cast(P.get())) d63 1 a63 1 PathDiagnosticNotePiece::~PathDiagnosticNotePiece() {} d67 3 a69 1 for (auto &Piece : *this) { d72 10 a81 6 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)); d85 1 a85 1 auto &Macro = cast(*Piece); d87 1 a87 1 Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros); d91 1 a91 1 Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros); d93 1 a93 1 Macro.subPieces = NewPath; a98 1 case PathDiagnosticPiece::Note: d105 1 d146 1 a146 1 dyn_cast(Path.back().get())) { a215 6 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"; d227 2 a228 4 } else if (SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } d235 2 a236 4 if (!L.isFileID() || SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } d238 2 a239 4 if (!L.isFileID() || SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } a280 1 d346 1 a346 1 case PathDiagnosticPiece::ControlFlow: d349 1 a349 2 case PathDiagnosticPiece::Event: case PathDiagnosticPiece::Note: d351 1 a351 1 case PathDiagnosticPiece::Macro: d354 1 a354 1 case PathDiagnosticPiece::Call: d508 1 d581 1 d583 2 a584 2 PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) { d589 3 a591 3 PathDiagnosticLocation::createBegin(const Stmt *S, const SourceManager &SM, LocationOrAnalysisDeclContext LAC) { d596 1 d608 2 a609 2 PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO, const SourceManager &SM) { d614 1 a614 1 PathDiagnosticLocation::createConditionalColonLoc( d622 2 a623 2 PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME, const SourceManager &SM) { d628 2 a629 2 PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS, const SourceManager &SM) { d635 2 a636 2 PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS, const SourceManager &SM) { d642 2 a643 2 PathDiagnosticLocation::createDeclBegin(const LocationContext *LC, const SourceManager &SM) { d656 2 a657 2 PathDiagnosticLocation::createDeclEnd(const LocationContext *LC, const SourceManager &SM) { d663 3 a665 2 PathDiagnosticLocation::create(const ProgramPoint& P, const SourceManager &SMng) { d883 3 a885 2 std::shared_ptr PathDiagnosticCallPiece::construct(const ExplodedNode *N, const CallExitEnd &CE, d891 1 a891 2 return std::shared_ptr( new PathDiagnosticCallPiece(caller, pos)); d897 1 a897 2 std::shared_ptr C( new PathDiagnosticCallPiece(path, caller)); d899 2 a900 3 auto *R = C.get(); path.push_front(std::move(C)); return R; d982 1 a982 1 std::shared_ptr d994 1 a994 1 return std::make_shared(callEnter, Out.str()); d997 1 a997 1 std::shared_ptr d1013 1 a1013 1 return std::make_shared(callEnterWithin, Out.str()); d1016 1 a1016 1 std::shared_ptr d1035 1 a1035 1 return std::make_shared(callReturn, Out.str()); d1065 1 a1106 4 void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticSpotPiece::Profile(ID); } @ 1.1.1.9 log @Import Clang pre-4.0.0 r291444. @ text @d32 3 a34 2 for (auto &P : subPieces) { if (isa(*P)) d36 1 a36 1 if (auto *MP = dyn_cast(P.get())) d63 1 a63 1 PathDiagnosticNotePiece::~PathDiagnosticNotePiece() {} d67 3 a69 1 for (auto &Piece : *this) { d72 10 a81 6 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)); d85 1 a85 1 auto &Macro = cast(*Piece); d87 1 a87 1 Macro.subPieces.flattenTo(Primary, Primary, ShouldFlattenMacros); d91 1 a91 1 Macro.subPieces.flattenTo(Primary, NewPath, ShouldFlattenMacros); d93 1 a93 1 Macro.subPieces = NewPath; a98 1 case PathDiagnosticPiece::Note: d105 1 d146 1 a146 1 dyn_cast(Path.back().get())) { a215 6 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"; d227 2 a228 4 } else if (SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } d235 2 a236 4 if (!L.isFileID() || SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } d238 2 a239 4 if (!L.isFileID() || SMgr.getFileID(L) != FID) { llvm::errs() << warning.str(); return; } a280 1 d346 1 a346 1 case PathDiagnosticPiece::ControlFlow: d349 1 a349 2 case PathDiagnosticPiece::Event: case PathDiagnosticPiece::Note: d351 1 a351 1 case PathDiagnosticPiece::Macro: d354 1 a354 1 case PathDiagnosticPiece::Call: d508 1 d581 1 d583 2 a584 2 PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) { d589 3 a591 3 PathDiagnosticLocation::createBegin(const Stmt *S, const SourceManager &SM, LocationOrAnalysisDeclContext LAC) { d596 1 d608 2 a609 2 PathDiagnosticLocation::createOperatorLoc(const BinaryOperator *BO, const SourceManager &SM) { d614 1 a614 1 PathDiagnosticLocation::createConditionalColonLoc( d622 2 a623 2 PathDiagnosticLocation::createMemberLoc(const MemberExpr *ME, const SourceManager &SM) { d628 2 a629 2 PathDiagnosticLocation::createBeginBrace(const CompoundStmt *CS, const SourceManager &SM) { d635 2 a636 2 PathDiagnosticLocation::createEndBrace(const CompoundStmt *CS, const SourceManager &SM) { d642 2 a643 2 PathDiagnosticLocation::createDeclBegin(const LocationContext *LC, const SourceManager &SM) { d656 2 a657 2 PathDiagnosticLocation::createDeclEnd(const LocationContext *LC, const SourceManager &SM) { d663 3 a665 2 PathDiagnosticLocation::create(const ProgramPoint& P, const SourceManager &SMng) { d883 3 a885 2 std::shared_ptr PathDiagnosticCallPiece::construct(const ExplodedNode *N, const CallExitEnd &CE, d891 1 a891 2 return std::shared_ptr( new PathDiagnosticCallPiece(caller, pos)); d897 1 a897 2 std::shared_ptr C( new PathDiagnosticCallPiece(path, caller)); d899 2 a900 3 auto *R = C.get(); path.push_front(std::move(C)); return R; d982 1 a982 1 std::shared_ptr d994 1 a994 1 return std::make_shared(callEnter, Out.str()); d997 1 a997 1 std::shared_ptr d1013 1 a1013 1 return std::make_shared(callEnterWithin, Out.str()); d1016 1 a1016 1 std::shared_ptr d1035 1 a1035 1 return std::make_shared(callReturn, Out.str()); d1065 1 a1106 4 void PathDiagnosticNotePiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticSpotPiece::Profile(ID); } @ 1.1.1.10 log @Import clang r309604 from branches/release_50 @ text @a580 1 case CFGElement::LifetimeEnds: a696 13 static const LocationContext * findTopAutosynthesizedParentContext(const LocationContext *LC) { assert(LC->getAnalysisDeclContext()->isBodyAutosynthesized()); const LocationContext *ParentLC = LC->getParent(); assert(ParentLC && "We don't start analysis from autosynthesized code"); while (ParentLC->getAnalysisDeclContext()->isBodyAutosynthesized()) { LC = ParentLC; ParentLC = LC->getParent(); assert(ParentLC && "We don't start analysis from autosynthesized code"); } return LC; } a697 10 // We cannot place diagnostics on autosynthesized code. // Put them onto the call site through which we jumped into autosynthesized // code for the first time. const LocationContext *LC = N->getLocationContext(); if (LC->getAnalysisDeclContext()->isBodyAutosynthesized()) { // It must be a stack frame because we only autosynthesize functions. return cast(findTopAutosynthesizedParentContext(LC)) ->getCallSite(); } // Otherwise, see if the node's program point directly points to a statement. a914 11 // 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 ObjCMethodDecl *MD = dyn_cast(Callee)) IsCalleeAnAutosynthesizedPropertyAccessor = ( MD->isPropertyAccessor() && CalleeCtx->getAnalysisDeclContext()->isBodyAutosynthesized()); d989 1 a989 5 // 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) d1023 1 a1023 5 // 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) @ 1.1.1.10.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===// a15 1 #include "clang/AST/DeclBase.h" a17 1 #include "clang/AST/DeclTemplate.h" a19 1 #include "clang/AST/OperationKinds.h" d21 1 a21 8 #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" a22 1 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" a23 6 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.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" a24 1 #include "llvm/ADT/SmallVector.h" a25 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a26 5 #include #include #include #include #include d32 1 a32 1 for (const auto &P : subPieces) { d35 1 a35 1 if (const auto *MP = dyn_cast(P.get())) d46 1 a46 1 return {}; d51 2 a52 1 : str(StripTrailingDots(s)), kind(k), Hint(hint) {} d55 1 a55 1 : kind(k), Hint(hint) {} d57 6 a62 11 PathDiagnosticPiece::~PathDiagnosticPiece() = default; PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default; PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default; PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default; PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default; PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default; d99 1 a99 1 PathDiagnostic::~PathDiagnostic() = default; d101 14 a114 12 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) {} d125 2 a126 2 assert(AnalysisManager::isInCodeFile(CallLoc, SMgr) && "The call piece should not be in a header file."); d129 1 a129 1 if (!AnalysisManager::isInCodeFile(CP->callEnterWithin.asLocation(), SMgr)) d138 2 a139 1 if (auto *CPInner = dyn_cast(Path.back().get())) d141 1 d157 1 a157 1 if (auto *CP = dyn_cast(LastP)) { d164 1 a164 1 const auto *ND = dyn_cast(CP->getCallee()); d181 1 a181 1 void PathDiagnosticConsumer::anchor() {} d185 4 a188 2 for (auto &Diag : Diags) delete &Diag; d219 3 a221 2 for (const auto &I : path) { const PathDiagnosticPiece *piece = I.get(); d233 3 a235 2 for (const auto &I : Ranges) { SourceLocation L = SMgr.getExpansionLoc(I.getBegin()); d240 1 a240 1 L = SMgr.getExpansionLoc(I.getEnd()); d247 2 a248 1 if (const auto *call = dyn_cast(piece)) d250 3 a252 1 else if (const auto *macro = dyn_cast(piece)) d254 1 a383 18 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(); } d388 1 a388 1 return compareCrossTUSourceLocs(XL, YL); d408 1 a408 2 return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM), FullSourceLoc(YDL, SM)); d432 5 a436 2 for (const auto &D : Diags) BatchDiags.push_back(&D); d453 3 a455 1 for (const auto D : BatchDiags) d457 1 a555 2 case CFGElement::Constructor: case CFGElement::CXXRecordTypedCall: d579 3 a581 14 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: a582 3 case CFGElement::LifetimeEnds: case CFGElement::LoopExit: llvm_unreachable("CFGElement kind should not be on callsite!"); d606 1 a606 1 if (const auto *CS = dyn_cast(S)) d625 1 d650 2 a651 1 if (const auto *CS = dyn_cast_or_null(LC->getDecl()->getBody())) a690 9 } else if (Optional BE = P.getAs()) { CFGElement BlockFront = BE->getBlock()->front(); if (auto StmtElt = BlockFront.getAs()) { return PathDiagnosticLocation(StmtElt->getStmt()->getLocStart(), SMng); } else if (auto NewAllocElt = BlockFront.getAs()) { return PathDiagnosticLocation( NewAllocElt->getAllocatorExpr()->getLocStart(), SMng); } llvm_unreachable("Unexpected CFG element at front of block"); a732 2 if (Optional CEB = P.getAs()) return CEB->getReturnStmt(); d782 1 a782 1 if (const auto *ME = dyn_cast(S)) d786 1 a786 1 if (const auto *B = dyn_cast(S)) d848 1 a848 1 const auto *DS = cast(S); d878 1 a878 1 if (const auto *MD = dyn_cast(D)) d880 1 a880 1 if (const auto *FD = dyn_cast(D)) { d890 1 a890 1 return SourceRange(Loc, Loc); d946 1 a946 1 if (const auto *MD = dyn_cast(Callee)) d952 2 a953 35 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()) { d956 1 a956 6 Out << Prefix << '\'' << *D; if (const auto T = dyn_cast(D)) describeTemplateParameters(Out, T->getTemplateArgs().asArray(), D->getASTContext().getLangOpts(), "<", ">"); Out << '\''; d971 1 a971 1 if (const auto *MD = dyn_cast(D)) { d980 1 a980 1 if (const auto *CD = dyn_cast(MD)) { d990 1 d999 1 d1003 1 d1007 1 d1018 1 a1018 10 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 << '\''; d1047 1 a1047 1 if (const auto *MD = dyn_cast(Callee)) d1087 5 a1091 3 for (const auto &I : pieces) { const PathDiagnosticPiece *piece = I.get(); if (const auto *cp = dyn_cast(piece)) d1093 1 d1121 4 a1124 3 for (const auto &I : Ranges) { ID.AddInteger(I.getBegin().getRawEncoding()); ID.AddInteger(I.getEnd().getRawEncoding()); d1130 4 a1133 2 for (const auto &I : path) ID.Add(*I); d1143 2 a1144 2 for (const auto &I : *this) ID.Add(I); d1149 3 a1151 2 for (const auto &I : subPieces) ID.Add(*I); d1167 2 a1168 2 for (const auto &I : path) ID.Add(*I); d1173 1 a1173 1 StackHintGenerator::~StackHintGenerator() = default; a1175 3 if (!N) return getMessageForSymbolNotFound(); d1181 1 a1181 1 const auto *CE = dyn_cast_or_null(CallSite); d1183 4 a1186 1 return {}; d1189 2 d1194 1 a1194 1 SVal SV = N->getSVal(*I); d1204 1 a1204 4 // Do not attempt to dereference void*. if ((*I)->getType()->isVoidPointerType()) continue; SVal PSV = N->getState()->getSVal(Reg->getRegion()); d1213 1 a1213 1 SVal SV = N->getSVal(CE); a1234 81 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 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; } } @ 1.1.1.10.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.10.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===// a15 1 #include "clang/AST/DeclBase.h" a17 1 #include "clang/AST/DeclTemplate.h" a19 1 #include "clang/AST/OperationKinds.h" d21 1 a21 8 #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" a22 1 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" a23 6 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.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" a24 1 #include "llvm/ADT/SmallVector.h" a25 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a26 5 #include #include #include #include #include d32 1 a32 1 for (const auto &P : subPieces) { d35 1 a35 1 if (const auto *MP = dyn_cast(P.get())) d46 1 a46 1 return {}; d51 2 a52 1 : str(StripTrailingDots(s)), kind(k), Hint(hint) {} d55 1 a55 1 : kind(k), Hint(hint) {} d57 6 a62 11 PathDiagnosticPiece::~PathDiagnosticPiece() = default; PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default; PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default; PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default; PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default; PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default; d99 1 a99 1 PathDiagnostic::~PathDiagnostic() = default; d101 14 a114 12 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) {} d125 2 a126 2 assert(AnalysisManager::isInCodeFile(CallLoc, SMgr) && "The call piece should not be in a header file."); d129 1 a129 1 if (!AnalysisManager::isInCodeFile(CP->callEnterWithin.asLocation(), SMgr)) d138 2 a139 1 if (auto *CPInner = dyn_cast(Path.back().get())) d141 1 d157 1 a157 1 if (auto *CP = dyn_cast(LastP)) { d164 1 a164 1 const auto *ND = dyn_cast(CP->getCallee()); d181 1 a181 1 void PathDiagnosticConsumer::anchor() {} d185 4 a188 2 for (auto &Diag : Diags) delete &Diag; d219 3 a221 2 for (const auto &I : path) { const PathDiagnosticPiece *piece = I.get(); d233 3 a235 2 for (const auto &I : Ranges) { SourceLocation L = SMgr.getExpansionLoc(I.getBegin()); d240 1 a240 1 L = SMgr.getExpansionLoc(I.getEnd()); d247 2 a248 1 if (const auto *call = dyn_cast(piece)) d250 3 a252 1 else if (const auto *macro = dyn_cast(piece)) d254 1 a383 18 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(); } d388 1 a388 1 return compareCrossTUSourceLocs(XL, YL); d408 1 a408 2 return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM), FullSourceLoc(YDL, SM)); d432 5 a436 2 for (const auto &D : Diags) BatchDiags.push_back(&D); d453 3 a455 1 for (const auto D : BatchDiags) d457 1 a555 2 case CFGElement::Constructor: case CFGElement::CXXRecordTypedCall: d579 3 a581 14 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: a582 3 case CFGElement::LifetimeEnds: case CFGElement::LoopExit: llvm_unreachable("CFGElement kind should not be on callsite!"); d606 1 a606 1 if (const auto *CS = dyn_cast(S)) d625 1 d650 2 a651 1 if (const auto *CS = dyn_cast_or_null(LC->getDecl()->getBody())) a690 9 } else if (Optional BE = P.getAs()) { CFGElement BlockFront = BE->getBlock()->front(); if (auto StmtElt = BlockFront.getAs()) { return PathDiagnosticLocation(StmtElt->getStmt()->getLocStart(), SMng); } else if (auto NewAllocElt = BlockFront.getAs()) { return PathDiagnosticLocation( NewAllocElt->getAllocatorExpr()->getLocStart(), SMng); } llvm_unreachable("Unexpected CFG element at front of block"); a732 2 if (Optional CEB = P.getAs()) return CEB->getReturnStmt(); d782 1 a782 1 if (const auto *ME = dyn_cast(S)) d786 1 a786 1 if (const auto *B = dyn_cast(S)) d848 1 a848 1 const auto *DS = cast(S); d878 1 a878 1 if (const auto *MD = dyn_cast(D)) d880 1 a880 1 if (const auto *FD = dyn_cast(D)) { d890 1 a890 1 return SourceRange(Loc, Loc); d946 1 a946 1 if (const auto *MD = dyn_cast(Callee)) d952 2 a953 35 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()) { d956 1 a956 6 Out << Prefix << '\'' << *D; if (const auto T = dyn_cast(D)) describeTemplateParameters(Out, T->getTemplateArgs().asArray(), D->getASTContext().getLangOpts(), "<", ">"); Out << '\''; d971 1 a971 1 if (const auto *MD = dyn_cast(D)) { d980 1 a980 1 if (const auto *CD = dyn_cast(MD)) { d990 1 d999 1 d1003 1 d1007 1 d1018 1 a1018 10 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 << '\''; d1047 1 a1047 1 if (const auto *MD = dyn_cast(Callee)) d1087 5 a1091 3 for (const auto &I : pieces) { const PathDiagnosticPiece *piece = I.get(); if (const auto *cp = dyn_cast(piece)) d1093 1 d1121 4 a1124 3 for (const auto &I : Ranges) { ID.AddInteger(I.getBegin().getRawEncoding()); ID.AddInteger(I.getEnd().getRawEncoding()); d1130 4 a1133 2 for (const auto &I : path) ID.Add(*I); d1143 2 a1144 2 for (const auto &I : *this) ID.Add(I); d1149 3 a1151 2 for (const auto &I : subPieces) ID.Add(*I); d1167 2 a1168 2 for (const auto &I : path) ID.Add(*I); d1173 1 a1173 1 StackHintGenerator::~StackHintGenerator() = default; a1175 3 if (!N) return getMessageForSymbolNotFound(); d1181 1 a1181 1 const auto *CE = dyn_cast_or_null(CallSite); d1183 4 a1186 1 return {}; d1189 2 d1194 1 a1194 1 SVal SV = N->getSVal(*I); d1204 1 a1204 4 // Do not attempt to dereference void*. if ((*I)->getType()->isVoidPointerType()) continue; SVal PSV = N->getState()->getSVal(Reg->getRegion()); d1213 1 a1213 1 SVal SV = N->getSVal(CE); a1234 81 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 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; } } @ 1.1.1.11 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -------------===// a15 1 #include "clang/AST/DeclBase.h" a17 1 #include "clang/AST/DeclTemplate.h" a19 1 #include "clang/AST/OperationKinds.h" d21 1 a21 8 #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" a22 1 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" a23 6 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.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" a24 1 #include "llvm/ADT/SmallVector.h" a25 3 #include "llvm/ADT/StringRef.h" #include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" a26 5 #include #include #include #include #include d32 1 a32 1 for (const auto &P : subPieces) { d35 1 a35 1 if (const auto *MP = dyn_cast(P.get())) d46 1 a46 1 return {}; d51 2 a52 1 : str(StripTrailingDots(s)), kind(k), Hint(hint) {} d55 1 a55 1 : kind(k), Hint(hint) {} d57 6 a62 11 PathDiagnosticPiece::~PathDiagnosticPiece() = default; PathDiagnosticEventPiece::~PathDiagnosticEventPiece() = default; PathDiagnosticCallPiece::~PathDiagnosticCallPiece() = default; PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() = default; PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() = default; PathDiagnosticNotePiece::~PathDiagnosticNotePiece() = default; d99 1 a99 1 PathDiagnostic::~PathDiagnostic() = default; d101 14 a114 12 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) {} d125 2 a126 2 assert(AnalysisManager::isInCodeFile(CallLoc, SMgr) && "The call piece should not be in a header file."); d129 1 a129 1 if (!AnalysisManager::isInCodeFile(CP->callEnterWithin.asLocation(), SMgr)) d138 2 a139 1 if (auto *CPInner = dyn_cast(Path.back().get())) d141 1 d157 1 a157 1 if (auto *CP = dyn_cast(LastP)) { d164 1 a164 1 const auto *ND = dyn_cast(CP->getCallee()); d181 1 a181 1 void PathDiagnosticConsumer::anchor() {} d185 4 a188 2 for (auto &Diag : Diags) delete &Diag; d219 3 a221 2 for (const auto &I : path) { const PathDiagnosticPiece *piece = I.get(); d233 3 a235 2 for (const auto &I : Ranges) { SourceLocation L = SMgr.getExpansionLoc(I.getBegin()); d240 1 a240 1 L = SMgr.getExpansionLoc(I.getEnd()); d247 2 a248 1 if (const auto *call = dyn_cast(piece)) d250 3 a252 1 else if (const auto *macro = dyn_cast(piece)) d254 1 a383 18 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(); } d388 1 a388 1 return compareCrossTUSourceLocs(XL, YL); d408 1 a408 2 return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM), FullSourceLoc(YDL, SM)); d432 5 a436 2 for (const auto &D : Diags) BatchDiags.push_back(&D); d453 3 a455 1 for (const auto D : BatchDiags) d457 1 a555 2 case CFGElement::Constructor: case CFGElement::CXXRecordTypedCall: d579 3 a581 14 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: a582 3 case CFGElement::LifetimeEnds: case CFGElement::LoopExit: llvm_unreachable("CFGElement kind should not be on callsite!"); d606 1 a606 1 if (const auto *CS = dyn_cast(S)) d625 1 d650 2 a651 1 if (const auto *CS = dyn_cast_or_null(LC->getDecl()->getBody())) a690 9 } else if (Optional BE = P.getAs()) { CFGElement BlockFront = BE->getBlock()->front(); if (auto StmtElt = BlockFront.getAs()) { return PathDiagnosticLocation(StmtElt->getStmt()->getLocStart(), SMng); } else if (auto NewAllocElt = BlockFront.getAs()) { return PathDiagnosticLocation( NewAllocElt->getAllocatorExpr()->getLocStart(), SMng); } llvm_unreachable("Unexpected CFG element at front of block"); a732 2 if (Optional CEB = P.getAs()) return CEB->getReturnStmt(); d782 1 a782 1 if (const auto *ME = dyn_cast(S)) d786 1 a786 1 if (const auto *B = dyn_cast(S)) d848 1 a848 1 const auto *DS = cast(S); d878 1 a878 1 if (const auto *MD = dyn_cast(D)) d880 1 a880 1 if (const auto *FD = dyn_cast(D)) { d890 1 a890 1 return SourceRange(Loc, Loc); d946 1 a946 1 if (const auto *MD = dyn_cast(Callee)) d952 2 a953 35 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()) { d956 1 a956 6 Out << Prefix << '\'' << *D; if (const auto T = dyn_cast(D)) describeTemplateParameters(Out, T->getTemplateArgs().asArray(), D->getASTContext().getLangOpts(), "<", ">"); Out << '\''; d971 1 a971 1 if (const auto *MD = dyn_cast(D)) { d980 1 a980 1 if (const auto *CD = dyn_cast(MD)) { d990 1 d999 1 d1003 1 d1007 1 d1018 1 a1018 10 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 << '\''; d1047 1 a1047 1 if (const auto *MD = dyn_cast(Callee)) d1087 5 a1091 3 for (const auto &I : pieces) { const PathDiagnosticPiece *piece = I.get(); if (const auto *cp = dyn_cast(piece)) d1093 1 d1121 4 a1124 3 for (const auto &I : Ranges) { ID.AddInteger(I.getBegin().getRawEncoding()); ID.AddInteger(I.getEnd().getRawEncoding()); d1130 4 a1133 2 for (const auto &I : path) ID.Add(*I); d1143 2 a1144 2 for (const auto &I : *this) ID.Add(I); d1149 3 a1151 2 for (const auto &I : subPieces) ID.Add(*I); d1167 2 a1168 2 for (const auto &I : path) ID.Add(*I); d1173 1 a1173 1 StackHintGenerator::~StackHintGenerator() = default; a1175 3 if (!N) return getMessageForSymbolNotFound(); d1181 1 a1181 1 const auto *CE = dyn_cast_or_null(CallSite); d1183 4 a1186 1 return {}; d1189 2 d1194 1 a1194 1 SVal SV = N->getSVal(*I); d1204 1 a1204 4 // Do not attempt to dereference void*. if ((*I)->getType()->isVoidPointerType()) continue; SVal PSV = N->getState()->getSVal(Reg->getRegion()); d1213 1 a1213 1 SVal SV = N->getSVal(CE); a1234 81 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 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; } } @ 1.1.1.12 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.6.4.1 log @file PathDiagnostic.cpp was added on branch tls-maxphys on 2014-08-19 23:47:32 +0000 @ text @d1 1182 @ 1.1.1.6.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1182 //===--- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the PathDiagnostic-related interfaces. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ParentMap.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; bool PathDiagnosticMacroPiece::containsEvent() const { for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I!=E; ++I) { if (isa(*I)) return true; if (PathDiagnosticMacroPiece *MP = dyn_cast(*I)) if (MP->containsEvent()) return true; } return false; } 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), LastInMainSourceFile(false) {} PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint) : kind(k), Hint(hint), LastInMainSourceFile(false) {} PathDiagnosticPiece::~PathDiagnosticPiece() {} PathDiagnosticEventPiece::~PathDiagnosticEventPiece() {} PathDiagnosticCallPiece::~PathDiagnosticCallPiece() {} PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() {} PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() {} PathPieces::~PathPieces() {} void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current, bool ShouldFlattenMacros) const { for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) { PathDiagnosticPiece *Piece = I->get(); switch (Piece->getKind()) { case PathDiagnosticPiece::Call: { PathDiagnosticCallPiece *Call = cast(Piece); IntrusiveRefCntPtr CallEnter = Call->getCallEnterEvent(); if (CallEnter) Current.push_back(CallEnter); Call->path.flattenTo(Primary, Primary, ShouldFlattenMacros); IntrusiveRefCntPtr callExit = Call->getCallExitEvent(); if (callExit) Current.push_back(callExit); break; } case PathDiagnosticPiece::Macro: { PathDiagnosticMacroPiece *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: Current.push_back(Piece); break; } } } PathDiagnostic::~PathDiagnostic() {} PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue, StringRef bugtype, StringRef verboseDesc, StringRef shortDesc, StringRef category, PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique) : CheckName(CheckName), DeclWithIssue(declWithIssue), BugType(StripTrailingDots(bugtype)), VerboseDesc(StripTrailingDots(verboseDesc)), ShortDesc(StripTrailingDots(shortDesc)), Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique), UniqueingDecl(DeclToUnique), path(pathImpl) {} static PathDiagnosticCallPiece * getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP, const SourceManager &SMgr) { SourceLocation CallLoc = CP->callEnter.asLocation(); // If the call is within a macro, don't do anything (for now). if (CallLoc.isMacroID()) return nullptr; assert(SMgr.isInMainFile(CallLoc) && "The call piece should be in the main file."); // Check if CP represents a path through a function outside of the main file. if (!SMgr.isInMainFile(CP->callEnterWithin.asLocation())) return CP; const PathPieces &Path = CP->path; if (Path.empty()) return nullptr; // Check if the last piece in the callee path is a call to a function outside // of the main file. if (PathDiagnosticCallPiece *CPInner = dyn_cast(Path.back())) { return getFirstStackedCallToHeaderFile(CPInner, SMgr); } // Otherwise, the last piece is in the main file. return nullptr; } void PathDiagnostic::resetDiagnosticLocationToMainFile() { if (path.empty()) return; PathDiagnosticPiece *LastP = path.back().get(); assert(LastP); const SourceManager &SMgr = LastP->getLocation().getManager(); // We only need to check if the report ends inside headers, if the last piece // is a call piece. if (PathDiagnosticCallPiece *CP = dyn_cast(LastP)) { CP = getFirstStackedCallToHeaderFile(CP, SMgr); if (CP) { // Mark the piece. CP->setAsLastInMainSourceFile(); // Update the path diagnostic message. const NamedDecl *ND = dyn_cast(CP->getCallee()); if (ND) { SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << " (within a call to '" << ND->getDeclName() << "')"; appendToDesc(os.str()); } // Reset the report containing declaration and location. DeclWithIssue = CP->getCaller(); Loc = CP->getLocation(); return; } } } void PathDiagnosticConsumer::anchor() { } PathDiagnosticConsumer::~PathDiagnosticConsumer() { // Delete the contents of the FoldingSet if it isn't empty already. for (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end() ; it != et ; ++it) { delete &*it; } } void PathDiagnosticConsumer::HandlePathDiagnostic(PathDiagnostic *D) { std::unique_ptr OwningD(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.begin())->getLocation().getManager(); SmallVector WorkList; WorkList.push_back(&D->path); while (!WorkList.empty()) { const PathPieces &path = *WorkList.pop_back_val(); for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) { const PathDiagnosticPiece *piece = I->get(); FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc(); if (FID.isInvalid()) { FID = SMgr.getFileID(L); } else if (SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? // Check the source ranges. ArrayRef Ranges = piece->getRanges(); for (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { SourceLocation L = SMgr.getExpansionLoc(I->getBegin()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? L = SMgr.getExpansionLoc(I->getEnd()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? } if (const PathDiagnosticCallPiece *call = dyn_cast(piece)) { WorkList.push_back(&call->path); } else if (const PathDiagnosticMacroPiece *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); Diags.RemoveNode(orig); delete orig; } Diags.InsertNode(OwningD.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 clang::ento::PathDiagnosticPiece::ControlFlow: return compareControlFlow(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Event: return None; case clang::ento::PathDiagnosticPiece::Macro: return compareMacro(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Call: return compareCall(cast(X), cast(Y)); } 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 compare(const PathDiagnostic &X, const PathDiagnostic &Y) { FullSourceLoc XL = X.getLocation().asLocation(); FullSourceLoc YL = Y.getLocation().asLocation(); if (XL != YL) return XL.isBeforeInTranslationUnitThan(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 SM.isBeforeInTranslationUnit(XDL, YDL); } } 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 (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end(); it != et; ++it) { const PathDiagnostic *D = &*it; BatchDiags.push_back(D); } // Sort the diagnostics so that they are always emitted in a deterministic // order. if (!BatchDiags.empty()) std::sort(BatchDiags.begin(), BatchDiags.end(), [](const PathDiagnostic *X, const PathDiagnostic *Y) { return X != Y && compare(*X, *Y); }); FlushDiagnosticsImpl(BatchDiags, Files); // Delete the flushed diagnostics. for (std::vector::iterator it = BatchDiags.begin(), et = BatchDiags.end(); it != et; ++it) { const PathDiagnostic *D = *it; delete D; } // Clear out the FoldingSet. Diags.clear(); } PathDiagnosticConsumer::FilesMade::~FilesMade() { for (PDFileEntry &Entry : *this) Entry.~PDFileEntry(); } void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, StringRef ConsumerName, StringRef FileName) { llvm::FoldingSetNodeID NodeID; NodeID.Add(PD); void *InsertPos; PDFileEntry *Entry = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) { Entry = Alloc.Allocate(); Entry = new (Entry) PDFileEntry(NodeID); 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 = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) return nullptr; return &Entry->files; } //===----------------------------------------------------------------------===// // PathDiagnosticLocation methods. //===----------------------------------------------------------------------===// static SourceLocation getValidSourceLocation(const Stmt* S, LocationOrAnalysisDeclContext LAC, bool UseEnd = false) { SourceLocation L = UseEnd ? S->getLocEnd() : S->getLocStart(); 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->getLocStart(); else L = ADC->getDecl()->getLocEnd(); break; } L = UseEnd ? Parent->getLocEnd() : Parent->getLocStart(); } while (!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: 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::TemporaryDtor: case CFGElement::NewAllocator: llvm_unreachable("not yet implemented!"); } llvm_unreachable("Unknown CFGElement kind"); } PathDiagnosticLocation PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) { return PathDiagnosticLocation(D->getLocStart(), 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 CompoundStmt *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) { return PathDiagnosticLocation(ME->getMemberLoc(), 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 CompoundStmt *CS = dyn_cast_or_null(LC->getDecl()->getBody())) if (!CS->body_empty()) { SourceLocation Loc = (*CS->body_begin())->getLocStart(); 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(); S = BSrc->getTerminatorCondition(); } 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 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 { llvm_unreachable("Unexpected ProgramPoint"); } return PathDiagnosticLocation(S, SMng, P.getLocationContext()); } const Stmt *PathDiagnosticLocation::getStmt(const ExplodedNode *N) { ProgramPoint P = N->getLocation(); if (Optional SP = P.getAs()) return SP->getStmt(); if (Optional BE = P.getAs()) return BE->getSrc()->getTerminator(); if (Optional CE = P.getAs()) return CE->getCallExpr(); if (Optional CEE = P.getAs()) return CEE->getCalleeContext()->getCallSite(); if (Optional PIPP = P.getAs()) return PIPP->getInitializer()->getInit(); return nullptr; } const Stmt *PathDiagnosticLocation::getNextStmt(const ExplodedNode *N) { for (N = N->getFirstSucc(); N; N = N->getFirstSucc()) { if (const Stmt *S = getStmt(N)) { // Check if the statement is '?' or '&&'/'||'. These are "merges", // not actual statement points. switch (S->getStmtClass()) { case Stmt::ChooseExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::ConditionalOperatorClass: continue; case Stmt::BinaryOperatorClass: { BinaryOperatorKind Op = cast(S)->getOpcode(); if (Op == BO_LAnd || Op == BO_LOr) continue; break; } default: break; } // We found the statement, so return it. return S; } } return nullptr; } PathDiagnosticLocation PathDiagnosticLocation::createEndOfPath(const ExplodedNode *N, const SourceManager &SM) { assert(N && "Cannot create a location with a null node."); const Stmt *S = getStmt(N); if (!S) { // If this is an implicit call, return the implicit call point location. if (Optional PIE = N->getLocationAs()) return PathDiagnosticLocation(PIE->getLocation(), SM); S = getNextStmt(N); } if (S) { ProgramPoint P = N->getLocation(); const LocationContext *LC = N->getLocationContext(); // For member expressions, return the location of the '.' or '->'. if (const MemberExpr *ME = dyn_cast(S)) return PathDiagnosticLocation::createMemberLoc(ME, SM); // For binary operators, return the location of the operator. if (const BinaryOperator *B = dyn_cast(S)) return PathDiagnosticLocation::createOperatorLoc(B, SM); if (P.getAs()) return PathDiagnosticLocation::createEnd(S, SM, LC); if (S->getLocStart().isValid()) return PathDiagnosticLocation(S, SM, LC); return PathDiagnosticLocation(getValidSourceLocation(S, LC), SM); } return createDeclEnd(N->getLocationContext(), SM); } 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 DeclStmt *DS = cast(S); if (DS->isSingleDecl()) { // Should always be the case, but we'll be defensive. return SourceRange(DS->getLocStart(), 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 ObjCMethodDecl *MD = dyn_cast(D)) return MD->getSourceRange(); if (const FunctionDecl *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. //===----------------------------------------------------------------------===// PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(const ExplodedNode *N, const CallExitEnd &CE, const SourceManager &SM) { const Decl *caller = CE.getLocationContext()->getDecl(); PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(), CE.getLocationContext(), SM); return new PathDiagnosticCallPiece(caller, pos); } PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(PathPieces &path, const Decl *caller) { PathDiagnosticCallPiece *C = new PathDiagnosticCallPiece(path, caller); path.clear(); path.push_front(C); return C; } 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); } static inline void describeClass(raw_ostream &Out, const CXXRecordDecl *D, StringRef Prefix = StringRef()) { if (!D->getIdentifier()) return; Out << Prefix << '\'' << *D << '\''; } 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 CXXMethodDecl *MD = dyn_cast(D)) { Out << Prefix; if (ExtendedDescription && !MD->isUserProvided()) { if (MD->isExplicitlyDefaulted()) Out << "defaulted "; else Out << "implicit "; } if (const CXXConstructorDecl *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) << '\''; return true; } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterEvent() const { if (!Callee) return nullptr; SmallString<256> buf; llvm::raw_svector_ostream Out(buf); Out << "Calling "; describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true); assert(callEnter.asLocation().isValid()); return new PathDiagnosticEventPiece(callEnter, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const { if (!callEnterWithin.asLocation().isValid()) return nullptr; if (Callee->isImplicit() || !Callee->hasBody()) return nullptr; if (const CXXMethodDecl *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 new PathDiagnosticEventPiece(callEnterWithin, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallExitEvent() const { if (NoExit) 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 new PathDiagnosticEventPiece(callReturn, Out.str()); } static void compute_path_size(const PathPieces &pieces, unsigned &size) { for (PathPieces::const_iterator it = pieces.begin(), et = pieces.end(); it != et; ++it) { const PathDiagnosticPiece *piece = it->get(); if (const PathDiagnosticCallPiece *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()); return; } 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 (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { ID.AddInteger(I->getBegin().getRawEncoding()); ID.AddInteger(I->getEnd().getRawEncoding()); } } void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticPiece::Profile(ID); for (PathPieces::const_iterator it = path.begin(), et = path.end(); it != et; ++it) { ID.Add(**it); } } 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_iterator I = begin(), E = end(); I != E; ++I) ID.Add(*I); } void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticSpotPiece::Profile(ID); for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I != E; ++I) ID.Add(**I); } 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 (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) ID.Add(**I); for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I) ID.AddString(*I); } StackHintGenerator::~StackHintGenerator() {} std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){ ProgramPoint P = N->getLocation(); CallExitEnd CExit = P.castAs(); // FIXME: Use CallEvent to abstract this over all calls. const Stmt *CallSite = CExit.getCalleeContext()->getCallSite(); const CallExpr *CE = dyn_cast_or_null(CallSite); if (!CE) return ""; if (!N) return getMessageForSymbolNotFound(); // Check if one of the parameters are set to the interesting symbol. ProgramStateRef State = N->getState(); const LocationContext *LCtx = N->getLocationContext(); unsigned ArgIndex = 0; for (CallExpr::const_arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I, ++ArgIndex){ SVal SV = State->getSVal(*I, LCtx); // Check if the variable corresponding to the symbol is passed by value. SymbolRef AS = SV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } // Check if the parameter is a pointer to the symbol. if (Optional Reg = SV.getAs()) { SVal PSV = State->getSVal(Reg->getRegion()); SymbolRef AS = PSV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } } } // Check if we are returning the interesting symbol. SVal SV = State->getSVal(CE, LCtx); SymbolRef RetSym = SV.getAsLocSymbol(); if (RetSym == Sym) { return getMessageForReturn(CE); } return getMessageForSymbolNotFound(); } std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE, unsigned ArgIndex) { // Printed parameters start at 1, not 0. ++ArgIndex; SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << Msg << " via " << ArgIndex << llvm::getOrdinalSuffix(ArgIndex) << " parameter"; return os.str(); } @ 1.1.1.4.4.1 log @file PathDiagnostic.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:31 +0000 @ text @d1 1184 @ 1.1.1.4.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1184 //===--- PathDiagnostic.cpp - Path-Specific Diagnostic Handling -*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines the PathDiagnostic-related interfaces. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/Expr.h" #include "clang/AST/ParentMap.h" #include "clang/AST/StmtCXX.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; bool PathDiagnosticMacroPiece::containsEvent() const { for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I!=E; ++I) { if (isa(*I)) return true; if (PathDiagnosticMacroPiece *MP = dyn_cast(*I)) if (MP->containsEvent()) return true; } return false; } 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), LastInMainSourceFile(false) {} PathDiagnosticPiece::PathDiagnosticPiece(Kind k, DisplayHint hint) : kind(k), Hint(hint), LastInMainSourceFile(false) {} PathDiagnosticPiece::~PathDiagnosticPiece() {} PathDiagnosticEventPiece::~PathDiagnosticEventPiece() {} PathDiagnosticCallPiece::~PathDiagnosticCallPiece() {} PathDiagnosticControlFlowPiece::~PathDiagnosticControlFlowPiece() {} PathDiagnosticMacroPiece::~PathDiagnosticMacroPiece() {} PathPieces::~PathPieces() {} void PathPieces::flattenTo(PathPieces &Primary, PathPieces &Current, bool ShouldFlattenMacros) const { for (PathPieces::const_iterator I = begin(), E = end(); I != E; ++I) { PathDiagnosticPiece *Piece = I->getPtr(); switch (Piece->getKind()) { case PathDiagnosticPiece::Call: { PathDiagnosticCallPiece *Call = cast(Piece); IntrusiveRefCntPtr CallEnter = Call->getCallEnterEvent(); if (CallEnter) Current.push_back(CallEnter); Call->path.flattenTo(Primary, Primary, ShouldFlattenMacros); IntrusiveRefCntPtr callExit = Call->getCallExitEvent(); if (callExit) Current.push_back(callExit); break; } case PathDiagnosticPiece::Macro: { PathDiagnosticMacroPiece *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: Current.push_back(Piece); break; } } } PathDiagnostic::~PathDiagnostic() {} PathDiagnostic::PathDiagnostic(StringRef CheckName, const Decl *declWithIssue, StringRef bugtype, StringRef verboseDesc, StringRef shortDesc, StringRef category, PathDiagnosticLocation LocationToUnique, const Decl *DeclToUnique) : CheckName(CheckName), DeclWithIssue(declWithIssue), BugType(StripTrailingDots(bugtype)), VerboseDesc(StripTrailingDots(verboseDesc)), ShortDesc(StripTrailingDots(shortDesc)), Category(StripTrailingDots(category)), UniqueingLoc(LocationToUnique), UniqueingDecl(DeclToUnique), path(pathImpl) {} static PathDiagnosticCallPiece * getFirstStackedCallToHeaderFile(PathDiagnosticCallPiece *CP, const SourceManager &SMgr) { SourceLocation CallLoc = CP->callEnter.asLocation(); // If the call is within a macro, don't do anything (for now). if (CallLoc.isMacroID()) return 0; assert(SMgr.isInMainFile(CallLoc) && "The call piece should be in the main file."); // Check if CP represents a path through a function outside of the main file. if (!SMgr.isInMainFile(CP->callEnterWithin.asLocation())) return CP; const PathPieces &Path = CP->path; if (Path.empty()) return 0; // Check if the last piece in the callee path is a call to a function outside // of the main file. if (PathDiagnosticCallPiece *CPInner = dyn_cast(Path.back())) { return getFirstStackedCallToHeaderFile(CPInner, SMgr); } // Otherwise, the last piece is in the main file. return 0; } void PathDiagnostic::resetDiagnosticLocationToMainFile() { if (path.empty()) return; PathDiagnosticPiece *LastP = path.back().getPtr(); assert(LastP); const SourceManager &SMgr = LastP->getLocation().getManager(); // We only need to check if the report ends inside headers, if the last piece // is a call piece. if (PathDiagnosticCallPiece *CP = dyn_cast(LastP)) { CP = getFirstStackedCallToHeaderFile(CP, SMgr); if (CP) { // Mark the piece. CP->setAsLastInMainSourceFile(); // Update the path diagnostic message. const NamedDecl *ND = dyn_cast(CP->getCallee()); if (ND) { SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << " (within a call to '" << ND->getDeclName() << "')"; appendToDesc(os.str()); } // Reset the report containing declaration and location. DeclWithIssue = CP->getCaller(); Loc = CP->getLocation(); return; } } } void PathDiagnosticConsumer::anchor() { } PathDiagnosticConsumer::~PathDiagnosticConsumer() { // Delete the contents of the FoldingSet if it isn't empty already. for (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end() ; it != et ; ++it) { delete &*it; } } void PathDiagnosticConsumer::HandlePathDiagnostic(PathDiagnostic *D) { OwningPtr OwningD(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.begin())->getLocation().getManager(); SmallVector WorkList; WorkList.push_back(&D->path); while (!WorkList.empty()) { const PathPieces &path = *WorkList.pop_back_val(); for (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) { const PathDiagnosticPiece *piece = I->getPtr(); FullSourceLoc L = piece->getLocation().asLocation().getExpansionLoc(); if (FID.isInvalid()) { FID = SMgr.getFileID(L); } else if (SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? // Check the source ranges. ArrayRef Ranges = piece->getRanges(); for (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { SourceLocation L = SMgr.getExpansionLoc(I->getBegin()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? L = SMgr.getExpansionLoc(I->getEnd()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? } if (const PathDiagnosticCallPiece *call = dyn_cast(piece)) { WorkList.push_back(&call->path); } else if (const PathDiagnosticMacroPiece *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 = 0; 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); Diags.RemoveNode(orig); delete orig; } Diags.InsertNode(OwningD.take()); } 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 clang::ento::PathDiagnosticPiece::ControlFlow: return compareControlFlow(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Event: return None; case clang::ento::PathDiagnosticPiece::Macro: return compareMacro(cast(X), cast(Y)); case clang::ento::PathDiagnosticPiece::Call: return compareCall(cast(X), cast(Y)); } 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 compare(const PathDiagnostic &X, const PathDiagnostic &Y) { FullSourceLoc XL = X.getLocation().asLocation(); FullSourceLoc YL = Y.getLocation().asLocation(); if (XL != YL) return XL.isBeforeInTranslationUnitThan(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 SM.isBeforeInTranslationUnit(XDL, YDL); } } 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(); } namespace { struct CompareDiagnostics { // Compare if 'X' is "<" than 'Y'. bool operator()(const PathDiagnostic *X, const PathDiagnostic *Y) const { if (X == Y) return false; return compare(*X, *Y); } }; } void PathDiagnosticConsumer::FlushDiagnostics( PathDiagnosticConsumer::FilesMade *Files) { if (flushed) return; flushed = true; std::vector BatchDiags; for (llvm::FoldingSet::iterator it = Diags.begin(), et = Diags.end(); it != et; ++it) { const PathDiagnostic *D = &*it; BatchDiags.push_back(D); } // Sort the diagnostics so that they are always emitted in a deterministic // order. if (!BatchDiags.empty()) std::sort(BatchDiags.begin(), BatchDiags.end(), CompareDiagnostics()); FlushDiagnosticsImpl(BatchDiags, Files); // Delete the flushed diagnostics. for (std::vector::iterator it = BatchDiags.begin(), et = BatchDiags.end(); it != et; ++it) { const PathDiagnostic *D = *it; delete D; } // Clear out the FoldingSet. Diags.clear(); } void PathDiagnosticConsumer::FilesMade::addDiagnostic(const PathDiagnostic &PD, StringRef ConsumerName, StringRef FileName) { llvm::FoldingSetNodeID NodeID; NodeID.Add(PD); void *InsertPos; PDFileEntry *Entry = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) { Entry = Alloc.Allocate(); Entry = new (Entry) PDFileEntry(NodeID); 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 = FindNodeOrInsertPos(NodeID, InsertPos); if (!Entry) return 0; return &Entry->files; } //===----------------------------------------------------------------------===// // PathDiagnosticLocation methods. //===----------------------------------------------------------------------===// static SourceLocation getValidSourceLocation(const Stmt* S, LocationOrAnalysisDeclContext LAC, bool UseEnd = false) { SourceLocation L = UseEnd ? S->getLocEnd() : S->getLocStart(); 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->getLocStart(); else L = ADC->getDecl()->getLocEnd(); break; } L = UseEnd ? Parent->getLocEnd() : Parent->getLocStart(); } while (!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: 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::TemporaryDtor: case CFGElement::NewAllocator: llvm_unreachable("not yet implemented!"); } llvm_unreachable("Unknown CFGElement kind"); } PathDiagnosticLocation PathDiagnosticLocation::createBegin(const Decl *D, const SourceManager &SM) { return PathDiagnosticLocation(D->getLocStart(), 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 CompoundStmt *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) { return PathDiagnosticLocation(ME->getMemberLoc(), 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 CompoundStmt *CS = dyn_cast_or_null(LC->getDecl()->getBody())) if (!CS->body_empty()) { SourceLocation Loc = (*CS->body_begin())->getLocStart(); 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 = 0; if (Optional BE = P.getAs()) { const CFGBlock *BSrc = BE->getSrc(); S = BSrc->getTerminatorCondition(); } 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 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 { llvm_unreachable("Unexpected ProgramPoint"); } return PathDiagnosticLocation(S, SMng, P.getLocationContext()); } const Stmt *PathDiagnosticLocation::getStmt(const ExplodedNode *N) { ProgramPoint P = N->getLocation(); if (Optional SP = P.getAs()) return SP->getStmt(); if (Optional BE = P.getAs()) return BE->getSrc()->getTerminator(); if (Optional CE = P.getAs()) return CE->getCallExpr(); if (Optional CEE = P.getAs()) return CEE->getCalleeContext()->getCallSite(); if (Optional PIPP = P.getAs()) return PIPP->getInitializer()->getInit(); return 0; } const Stmt *PathDiagnosticLocation::getNextStmt(const ExplodedNode *N) { for (N = N->getFirstSucc(); N; N = N->getFirstSucc()) { if (const Stmt *S = getStmt(N)) { // Check if the statement is '?' or '&&'/'||'. These are "merges", // not actual statement points. switch (S->getStmtClass()) { case Stmt::ChooseExprClass: case Stmt::BinaryConditionalOperatorClass: case Stmt::ConditionalOperatorClass: continue; case Stmt::BinaryOperatorClass: { BinaryOperatorKind Op = cast(S)->getOpcode(); if (Op == BO_LAnd || Op == BO_LOr) continue; break; } default: break; } // We found the statement, so return it. return S; } } return 0; } PathDiagnosticLocation PathDiagnosticLocation::createEndOfPath(const ExplodedNode *N, const SourceManager &SM) { assert(N && "Cannot create a location with a null node."); const Stmt *S = getStmt(N); if (!S) { // If this is an implicit call, return the implicit call point location. if (Optional PIE = N->getLocationAs()) return PathDiagnosticLocation(PIE->getLocation(), SM); S = getNextStmt(N); } if (S) { ProgramPoint P = N->getLocation(); const LocationContext *LC = N->getLocationContext(); // For member expressions, return the location of the '.' or '->'. if (const MemberExpr *ME = dyn_cast(S)) return PathDiagnosticLocation::createMemberLoc(ME, SM); // For binary operators, return the location of the operator. if (const BinaryOperator *B = dyn_cast(S)) return PathDiagnosticLocation::createOperatorLoc(B, SM); if (P.getAs()) return PathDiagnosticLocation::createEnd(S, SM, LC); if (S->getLocStart().isValid()) return PathDiagnosticLocation(S, SM, LC); return PathDiagnosticLocation(getValidSourceLocation(S, LC), SM); } return createDeclEnd(N->getLocationContext(), SM); } 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 DeclStmt *DS = cast(S); if (DS->isSingleDecl()) { // Should always be the case, but we'll be defensive. return SourceRange(DS->getLocStart(), 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 ObjCMethodDecl *MD = dyn_cast(D)) return MD->getSourceRange(); if (const FunctionDecl *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 = 0; D = 0; } else if (K == DeclK) { K = SingleLocK; S = 0; D = 0; } } //===----------------------------------------------------------------------===// // Manipulation of PathDiagnosticCallPieces. //===----------------------------------------------------------------------===// PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(const ExplodedNode *N, const CallExitEnd &CE, const SourceManager &SM) { const Decl *caller = CE.getLocationContext()->getDecl(); PathDiagnosticLocation pos = getLocationForCaller(CE.getCalleeContext(), CE.getLocationContext(), SM); return new PathDiagnosticCallPiece(caller, pos); } PathDiagnosticCallPiece * PathDiagnosticCallPiece::construct(PathPieces &path, const Decl *caller) { PathDiagnosticCallPiece *C = new PathDiagnosticCallPiece(path, caller); path.clear(); path.push_front(C); return C; } 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); } static inline void describeClass(raw_ostream &Out, const CXXRecordDecl *D, StringRef Prefix = StringRef()) { if (!D->getIdentifier()) return; Out << Prefix << '\'' << *D << '\''; } 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 CXXMethodDecl *MD = dyn_cast(D)) { Out << Prefix; if (ExtendedDescription && !MD->isUserProvided()) { if (MD->isExplicitlyDefaulted()) Out << "defaulted "; else Out << "implicit "; } if (const CXXConstructorDecl *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) << '\''; return true; } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterEvent() const { if (!Callee) return 0; SmallString<256> buf; llvm::raw_svector_ostream Out(buf); Out << "Calling "; describeCodeDecl(Out, Callee, /*ExtendedDescription=*/true); assert(callEnter.asLocation().isValid()); return new PathDiagnosticEventPiece(callEnter, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallEnterWithinCallerEvent() const { if (!callEnterWithin.asLocation().isValid()) return 0; if (Callee->isImplicit() || !Callee->hasBody()) return 0; if (const CXXMethodDecl *MD = dyn_cast(Callee)) if (MD->isDefaulted()) return 0; SmallString<256> buf; llvm::raw_svector_ostream Out(buf); Out << "Entered call"; describeCodeDecl(Out, Caller, /*ExtendedDescription=*/false, " from "); return new PathDiagnosticEventPiece(callEnterWithin, Out.str()); } IntrusiveRefCntPtr PathDiagnosticCallPiece::getCallExitEvent() const { if (NoExit) return 0; 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 new PathDiagnosticEventPiece(callReturn, Out.str()); } static void compute_path_size(const PathPieces &pieces, unsigned &size) { for (PathPieces::const_iterator it = pieces.begin(), et = pieces.end(); it != et; ++it) { const PathDiagnosticPiece *piece = it->getPtr(); if (const PathDiagnosticCallPiece *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()); return; } 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 (ArrayRef::iterator I = Ranges.begin(), E = Ranges.end(); I != E; ++I) { ID.AddInteger(I->getBegin().getRawEncoding()); ID.AddInteger(I->getEnd().getRawEncoding()); } } void PathDiagnosticCallPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticPiece::Profile(ID); for (PathPieces::const_iterator it = path.begin(), et = path.end(); it != et; ++it) { ID.Add(**it); } } 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_iterator I = begin(), E = end(); I != E; ++I) ID.Add(*I); } void PathDiagnosticMacroPiece::Profile(llvm::FoldingSetNodeID &ID) const { PathDiagnosticSpotPiece::Profile(ID); for (PathPieces::const_iterator I = subPieces.begin(), E = subPieces.end(); I != E; ++I) ID.Add(**I); } 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 (PathPieces::const_iterator I = path.begin(), E = path.end(); I != E; ++I) ID.Add(**I); for (meta_iterator I = meta_begin(), E = meta_end(); I != E; ++I) ID.AddString(*I); } StackHintGenerator::~StackHintGenerator() {} std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){ ProgramPoint P = N->getLocation(); CallExitEnd CExit = P.castAs(); // FIXME: Use CallEvent to abstract this over all calls. const Stmt *CallSite = CExit.getCalleeContext()->getCallSite(); const CallExpr *CE = dyn_cast_or_null(CallSite); if (!CE) return ""; if (!N) return getMessageForSymbolNotFound(); // Check if one of the parameters are set to the interesting symbol. ProgramStateRef State = N->getState(); const LocationContext *LCtx = N->getLocationContext(); unsigned ArgIndex = 0; for (CallExpr::const_arg_iterator I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I, ++ArgIndex){ SVal SV = State->getSVal(*I, LCtx); // Check if the variable corresponding to the symbol is passed by value. SymbolRef AS = SV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } // Check if the parameter is a pointer to the symbol. if (Optional Reg = SV.getAs()) { SVal PSV = State->getSVal(Reg->getRegion()); SymbolRef AS = PSV.getAsLocSymbol(); if (AS == Sym) { return getMessageForArg(*I, ArgIndex); } } } // Check if we are returning the interesting symbol. SVal SV = State->getSVal(CE, LCtx); SymbolRef RetSym = SV.getAsLocSymbol(); if (RetSym == Sym) { return getMessageForReturn(CE); } return getMessageForSymbolNotFound(); } std::string StackHintGeneratorForSymbol::getMessageForArg(const Expr *ArgE, unsigned ArgIndex) { // Printed parameters start at 1, not 0. ++ArgIndex; SmallString<200> buf; llvm::raw_svector_ostream os(buf); os << Msg << " via " << ArgIndex << llvm::getOrdinalSuffix(ArgIndex) << " parameter"; return os.str(); } @