| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Reusables.h" |
| #include "clang/Frontend/CompilerInstance.h" |
| #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" |
| #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" |
| #include "clang/StaticAnalyzer/Core/Checker.h" |
| #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h" |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h" |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" |
| #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h" |
| #include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h" |
| #include "clang/Tooling/Tooling.h" |
| #include "gtest/gtest.h" |
| |
| using namespace clang; |
| using namespace ento; |
| using namespace llvm; |
| |
| namespace { |
| |
| class InterestingnessTestChecker : public Checker<check::PreCall> { |
| BugType BT_TestBug; |
| |
| using HandlerFn = std::function<void(const InterestingnessTestChecker *, |
| const CallEvent &, CheckerContext &)>; |
| |
| CallDescriptionMap<HandlerFn> Handlers = { |
| {{{"setInteresting"}, 1}, &InterestingnessTestChecker::handleInteresting}, |
| {{{"setNotInteresting"}, 1}, |
| &InterestingnessTestChecker::handleNotInteresting}, |
| {{{"check"}, 1}, &InterestingnessTestChecker::handleCheck}, |
| {{{"bug"}, 1}, &InterestingnessTestChecker::handleBug}, |
| }; |
| |
| void handleInteresting(const CallEvent &Call, CheckerContext &C) const; |
| void handleNotInteresting(const CallEvent &Call, CheckerContext &C) const; |
| void handleCheck(const CallEvent &Call, CheckerContext &C) const; |
| void handleBug(const CallEvent &Call, CheckerContext &C) const; |
| |
| public: |
| InterestingnessTestChecker() |
| : BT_TestBug(this, "InterestingnessTestBug", "Test") {} |
| |
| void checkPreCall(const CallEvent &Call, CheckerContext &C) const { |
| const HandlerFn *Handler = Handlers.lookup(Call); |
| if (!Handler) |
| return; |
| |
| (*Handler)(this, Call, C); |
| } |
| }; |
| |
| } // namespace |
| |
| void InterestingnessTestChecker::handleInteresting(const CallEvent &Call, |
| CheckerContext &C) const { |
| SymbolRef Sym = Call.getArgSVal(0).getAsSymbol(); |
| assert(Sym); |
| C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) { |
| BR.markInteresting(Sym); |
| return ""; |
| })); |
| } |
| |
| void InterestingnessTestChecker::handleNotInteresting(const CallEvent &Call, |
| CheckerContext &C) const { |
| SymbolRef Sym = Call.getArgSVal(0).getAsSymbol(); |
| assert(Sym); |
| C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) { |
| BR.markNotInteresting(Sym); |
| return ""; |
| })); |
| } |
| |
| void InterestingnessTestChecker::handleCheck(const CallEvent &Call, |
| CheckerContext &C) const { |
| SymbolRef Sym = Call.getArgSVal(0).getAsSymbol(); |
| assert(Sym); |
| C.addTransition(nullptr, C.getNoteTag([Sym](PathSensitiveBugReport &BR) { |
| if (BR.isInteresting(Sym)) |
| return "Interesting"; |
| else |
| return "NotInteresting"; |
| })); |
| } |
| |
| void InterestingnessTestChecker::handleBug(const CallEvent &Call, |
| CheckerContext &C) const { |
| ExplodedNode *N = C.generateErrorNode(); |
| C.emitReport( |
| std::make_unique<PathSensitiveBugReport>(BT_TestBug, "test bug", N)); |
| } |
| |
| namespace { |
| |
| class TestAction : public ASTFrontendAction { |
| ExpectedDiagsTy ExpectedDiags; |
| |
| public: |
| TestAction(ExpectedDiagsTy &&ExpectedDiags) |
| : ExpectedDiags(std::move(ExpectedDiags)) {} |
| |
| std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler, |
| StringRef File) override { |
| std::unique_ptr<AnalysisASTConsumer> AnalysisConsumer = |
| CreateAnalysisConsumer(Compiler); |
| AnalysisConsumer->AddDiagnosticConsumer(new VerifyPathDiagnosticConsumer( |
| std::move(ExpectedDiags), Compiler.getSourceManager())); |
| AnalysisConsumer->AddCheckerRegistrationFn([](CheckerRegistry &Registry) { |
| Registry.addChecker<InterestingnessTestChecker>("test.Interestingness", |
| "Description", ""); |
| }); |
| Compiler.getAnalyzerOpts().CheckersAndPackages = { |
| {"test.Interestingness", true}}; |
| return std::move(AnalysisConsumer); |
| } |
| }; |
| |
| } // namespace |
| |
| TEST(BugReportInterestingness, Symbols) { |
| EXPECT_TRUE(tooling::runToolOnCode( |
| std::make_unique<TestAction>(ExpectedDiagsTy{ |
| {{15, 7}, |
| "test bug", |
| "test bug", |
| "test.Interestingness", |
| "InterestingnessTestBug", |
| "Test", |
| { |
| {{8, 7}, "Interesting", {{{8, 7}, {8, 14}}}}, |
| {{10, 7}, "NotInteresting", {{{10, 7}, {10, 14}}}}, |
| {{12, 7}, "Interesting", {{{12, 7}, {12, 14}}}}, |
| {{14, 7}, "NotInteresting", {{{14, 7}, {14, 14}}}}, |
| {{15, 7}, "test bug", {{{15, 7}, {15, 12}}}}, |
| }}}), |
| R"( |
| void setInteresting(int); |
| void setNotInteresting(int); |
| void check(int); |
| void bug(int); |
| |
| void f(int A) { |
| check(A); |
| setInteresting(A); |
| check(A); |
| setNotInteresting(A); |
| check(A); |
| setInteresting(A); |
| check(A); |
| bug(A); |
| } |
| )", |
| "input.cpp")); |
| } |