[clang] 3595189 - [clang][dataflow] Allow clients to disable built-in transfer functions.
Yitzhak Mandelbaum via cfe-commits
cfe-commits at lists.llvm.org
Wed Jan 26 09:25:29 PST 2022
Author: Yitzhak Mandelbaum
Date: 2022-01-26T17:24:59Z
New Revision: 3595189217e684fcdaa87a78077d97f29549f560
URL: https://github.com/llvm/llvm-project/commit/3595189217e684fcdaa87a78077d97f29549f560
DIFF: https://github.com/llvm/llvm-project/commit/3595189217e684fcdaa87a78077d97f29549f560.diff
LOG: [clang][dataflow] Allow clients to disable built-in transfer functions.
These built-in functions build the (sophisticated) model of the code's
memory. This model isn't used by all analyses, so we provide for disabling it to
avoid incurring the costs associated with its construction.
Differential Revision: https://reviews.llvm.org/D118178
Added:
Modified:
clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h
clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
clang/unittests/Analysis/FlowSensitive/TransferTest.cpp
clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
index 38a64a277412b..f327abe63751f 100644
--- a/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/DataflowAnalysis.h
@@ -62,6 +62,8 @@ class DataflowAnalysis : public TypeErasedDataflowAnalysis {
using Lattice = LatticeT;
explicit DataflowAnalysis(ASTContext &Context) : Context(Context) {}
+ explicit DataflowAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
+ : TypeErasedDataflowAnalysis(ApplyBuiltinTransfer), Context(Context) {}
ASTContext &getASTContext() final { return Context; }
diff --git a/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h b/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
index 3c25c8fc2f28f..9f44475b14ba1 100644
--- a/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
+++ b/clang/include/clang/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.h
@@ -41,7 +41,17 @@ struct TypeErasedLattice {
/// Type-erased base class for dataflow analyses built on a single lattice type.
class TypeErasedDataflowAnalysis : public Environment::Merger {
+ /// Determines whether to apply the built-in transfer functions.
+ // FIXME: Remove this option once the framework supports composing analyses
+ // (at which point the built-in transfer functions can be simply a standalone
+ // analysis).
+ bool ApplyBuiltinTransfer;
+
public:
+ TypeErasedDataflowAnalysis() : ApplyBuiltinTransfer(true) {}
+ TypeErasedDataflowAnalysis(bool ApplyBuiltinTransfer)
+ : ApplyBuiltinTransfer(ApplyBuiltinTransfer) {}
+
virtual ~TypeErasedDataflowAnalysis() {}
/// Returns the `ASTContext` that is used by the analysis.
@@ -66,6 +76,10 @@ class TypeErasedDataflowAnalysis : public Environment::Merger {
/// type-erased lattice element.
virtual void transferTypeErased(const Stmt *, TypeErasedLattice &,
Environment &) = 0;
+
+ /// Determines whether to apply the built-in transfer functions, which model
+ /// the heap and stack in the `Environment`.
+ bool applyBuiltinTransfer() const { return ApplyBuiltinTransfer; }
};
/// Type-erased model of the program at a given program point.
diff --git a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
index 0a5f89ce41ad2..aaf6a834f5b3a 100644
--- a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
+++ b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
@@ -119,7 +119,8 @@ transferCFGStmt(const CFGStmt &CfgStmt, TypeErasedDataflowAnalysis &Analysis,
const Stmt *S = CfgStmt.getStmt();
assert(S != nullptr);
- transfer(*S, State.Env);
+ if (Analysis.applyBuiltinTransfer())
+ transfer(*S, State.Env);
Analysis.transferTypeErased(S, State.Lattice, State.Env);
if (HandleTransferredStmt != nullptr)
@@ -178,7 +179,8 @@ TypeErasedDataflowAnalysisState transferBlock(
HandleTransferredStmt);
break;
case CFGElement::Initializer:
- transferCFGInitializer(*Element.getAs<CFGInitializer>(), State);
+ if (Analysis.applyBuiltinTransfer())
+ transferCFGInitializer(*Element.getAs<CFGInitializer>(), State);
break;
default:
// FIXME: Evaluate other kinds of `CFGElement`.
diff --git a/clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h b/clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h
index fc24a2b71421b..eab5782095bbc 100644
--- a/clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h
+++ b/clang/unittests/Analysis/FlowSensitive/NoopAnalysis.h
@@ -39,8 +39,13 @@ inline std::ostream &operator<<(std::ostream &OS, const NoopLattice &) {
class NoopAnalysis : public DataflowAnalysis<NoopAnalysis, NoopLattice> {
public:
- NoopAnalysis(ASTContext &Context)
- : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context) {}
+ /// `ApplyBuiltinTransfer` controls whether to run the built-in transfer
+ /// functions that model memory during the analysis. Their results are not
+ /// used by `NoopAnalysis`, but tests that need to inspect the environment
+ /// should enable them.
+ NoopAnalysis(ASTContext &Context, bool ApplyBuiltinTransfer)
+ : DataflowAnalysis<NoopAnalysis, NoopLattice>(Context,
+ ApplyBuiltinTransfer) {}
static NoopLattice initialElement() { return {}; }
diff --git a/clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp b/clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
index aa3b6f9dc9663..960879025307f 100644
--- a/clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
@@ -79,12 +79,12 @@ void checkDataflow(
ASTContext &)>
Expectations) {
ASSERT_THAT_ERROR(
- test::checkDataflow<NoopAnalysis>(Code, Target,
- [](ASTContext &Context, Environment &) {
- return NoopAnalysis(Context);
- },
- std::move(Expectations),
- {"-fsyntax-only", "-std=c++17"}),
+ test::checkDataflow<NoopAnalysis>(
+ Code, Target,
+ [](ASTContext &Context, Environment &) {
+ return NoopAnalysis(Context, /*ApplyBuiltinTransfer=*/false);
+ },
+ std::move(Expectations), {"-fsyntax-only", "-std=c++17"}),
llvm::Succeeded());
}
diff --git a/clang/unittests/Analysis/FlowSensitive/TransferTest.cpp b/clang/unittests/Analysis/FlowSensitive/TransferTest.cpp
index 30238a40fec59..978768333c386 100644
--- a/clang/unittests/Analysis/FlowSensitive/TransferTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/TransferTest.cpp
@@ -40,11 +40,14 @@ class TransferTest : public ::testing::Test {
protected:
template <typename Matcher>
void runDataflow(llvm::StringRef Code, Matcher Match,
- LangStandard::Kind Std = LangStandard::lang_cxx17) {
+ LangStandard::Kind Std = LangStandard::lang_cxx17,
+ bool ApplyBuiltinTransfer = true) {
ASSERT_THAT_ERROR(
test::checkDataflow<NoopAnalysis>(
Code, "target",
- [](ASTContext &C, Environment &) { return NoopAnalysis(C); },
+ [ApplyBuiltinTransfer](ASTContext &C, Environment &) {
+ return NoopAnalysis(C, ApplyBuiltinTransfer);
+ },
[&Match](
llvm::ArrayRef<
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
@@ -58,6 +61,31 @@ class TransferTest : public ::testing::Test {
}
};
+TEST_F(TransferTest, IntVarDeclNotTrackedWhenTransferDisabled) {
+ std::string Code = R"(
+ void target() {
+ int Foo;
+ // [[p]]
+ }
+ )";
+ runDataflow(
+ Code,
+ [](llvm::ArrayRef<
+ std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
+ Results,
+ ASTContext &ASTCtx) {
+ ASSERT_THAT(Results, ElementsAre(Pair("p", _)));
+ const Environment &Env = Results[0].second.Env;
+
+ const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
+ ASSERT_THAT(FooDecl, NotNull());
+
+ EXPECT_EQ(Env.getStorageLocation(*FooDecl, SkipPast::None), nullptr);
+ },
+ LangStandard::lang_cxx17,
+ /*ApplyBuiltinTransfer=*/false);
+}
+
TEST_F(TransferTest, IntVarDecl) {
std::string Code = R"(
void target() {
diff --git a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
index efb1cb728fa48..ee0bc3ed5e251 100644
--- a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -51,6 +51,8 @@ using ::testing::UnorderedElementsAre;
template <typename AnalysisT>
class AnalysisCallback : public ast_matchers::MatchFinder::MatchCallback {
public:
+ AnalysisCallback(AnalysisT (*MakeAnalysis)(ASTContext &))
+ : MakeAnalysis(MakeAnalysis) {}
void run(const ast_matchers::MatchFinder::MatchResult &Result) override {
assert(BlockStates.empty());
@@ -63,12 +65,13 @@ class AnalysisCallback : public ast_matchers::MatchFinder::MatchCallback {
auto CFCtx = llvm::cantFail(
ControlFlowContext::build(nullptr, Body, Result.Context));
- AnalysisT Analysis(*Result.Context);
+ AnalysisT Analysis = MakeAnalysis(*Result.Context);
DataflowAnalysisContext DACtx;
Environment Env(DACtx);
BlockStates = runDataflowAnalysis(CFCtx, Analysis, Env);
}
+ AnalysisT (*MakeAnalysis)(ASTContext &);
std::vector<
llvm::Optional<DataflowAnalysisState<typename AnalysisT::Lattice>>>
BlockStates;
@@ -76,11 +79,11 @@ class AnalysisCallback : public ast_matchers::MatchFinder::MatchCallback {
template <typename AnalysisT>
std::vector<llvm::Optional<DataflowAnalysisState<typename AnalysisT::Lattice>>>
-runAnalysis(llvm::StringRef Code) {
+runAnalysis(llvm::StringRef Code, AnalysisT (*MakeAnalysis)(ASTContext &)) {
std::unique_ptr<ASTUnit> AST =
tooling::buildASTFromCodeWithArgs(Code, {"-std=c++11"});
- AnalysisCallback<AnalysisT> Callback;
+ AnalysisCallback<AnalysisT> Callback(MakeAnalysis);
ast_matchers::MatchFinder Finder;
Finder.addMatcher(
ast_matchers::functionDecl(ast_matchers::hasName("target")).bind("func"),
@@ -91,9 +94,8 @@ runAnalysis(llvm::StringRef Code) {
}
TEST(DataflowAnalysisTest, NoopAnalysis) {
- auto BlockStates = runAnalysis<NoopAnalysis>(R"(
- void target() {}
- )");
+ auto BlockStates = runAnalysis<NoopAnalysis>(
+ "void target() {}", [](ASTContext &C) { return NoopAnalysis(C, false); });
EXPECT_EQ(BlockStates.size(), 2u);
EXPECT_TRUE(BlockStates[0].hasValue());
EXPECT_TRUE(BlockStates[1].hasValue());
@@ -118,8 +120,9 @@ class NonConvergingAnalysis
: public DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice> {
public:
explicit NonConvergingAnalysis(ASTContext &Context)
- : DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice>(Context) {
- }
+ : DataflowAnalysis<NonConvergingAnalysis, NonConvergingLattice>(
+ Context,
+ /*ApplyBuiltinTransfer=*/false) {}
static NonConvergingLattice initialElement() { return {0}; }
@@ -129,11 +132,13 @@ class NonConvergingAnalysis
};
TEST(DataflowAnalysisTest, NonConvergingAnalysis) {
- auto BlockStates = runAnalysis<NonConvergingAnalysis>(R"(
+ auto BlockStates = runAnalysis<NonConvergingAnalysis>(
+ R"(
void target() {
while(true) {}
}
- )");
+ )",
+ [](ASTContext &C) { return NonConvergingAnalysis(C); });
EXPECT_EQ(BlockStates.size(), 4u);
EXPECT_TRUE(BlockStates[0].hasValue());
EXPECT_TRUE(BlockStates[1].hasValue());
More information about the cfe-commits
mailing list