This is an archive of the discontinued LLVM Phabricator instance.

Differential D155813

[clang][dataflow] Remove checks that test for consistency between `StructValue` and `AggregateStorageLocation`.
ClosedPublic

Authored by mboehme on Jul 20 2023, 4:17 AM.

Details

Reviewers
ymandel
xazax.hun
Commits
rGc3cf630d80a2: [clang][dataflow] Remove checks that test for consistency between `StructValue`…
Summary

Now that the redundancy between these two classes has been eliminated, these
checks aren't needed any more.

Diff Detail

Event Timeline

mboehme created this revision.Jul 20 2023, 4:17 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 20 2023, 4:17 AM
Herald added subscribers: martong, xazax.hun. · View Herald Transcript
mboehme requested review of this revision.Jul 20 2023, 4:17 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 20 2023, 4:17 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B246850: Diff 542422.Jul 20 2023, 4:18 AM
mboehme added a parent revision: D155446: [clang][dataflow] Eliminate duplication between `AggregateStorageLocation` and `StructValue`..Jul 20 2023, 4:18 AM
mboehme added reviewers: ymandel, xazax.hun.
ymandel accepted this revision.Jul 20 2023, 5:20 AM
This revision is now accepted and ready to land.Jul 20 2023, 5:20 AM
mboehme added a child revision: D155922: [clang][dataflow] Eliminate `ReferenceValue`..Jul 21 2023, 12:54 AM
xazax.hun accepted this revision.Jul 21 2023, 4:24 PM
This revision was landed with ongoing or failed builds.Jul 24 2023, 6:20 AM
Closed by commit rGc3cf630d80a2: [clang][dataflow] Remove checks that test for consistency between `StructValue`… (authored by mboehme). · Explain Why
This revision was automatically updated to reflect the committed changes.
mboehme added a commit: rGc3cf630d80a2: [clang][dataflow] Remove checks that test for consistency between `StructValue`….
mboehme mentioned this in D156229: [clang][dataflow] Remove checks that test for consistency between `StructValue` and `AggregateStorageLocation`..Jul 26 2023, 5:18 AM
mboehme removed a child revision: D155922: [clang][dataflow] Eliminate `ReferenceValue`..

Revision Contents

PathSize
clang/
unittests/
Analysis/
FlowSensitive/
84 lines

Diff 543509

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

Show All 21 Lines
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <optional> #include <optional>
#include <string> #include <string>
#include <utility> #include <utility>
// FIXME: There are still remaining checks here that check for consistency
// between `StructValue` and `AggregateStorageLocation`. Now that the redundancy
// between these two classes has been eliminated, these checks aren't needed any
// more, so remove them.
namespace { namespace {
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
using namespace test; using namespace test;
using ::testing::Eq; using ::testing::Eq;
using ::testing::IsNull; using ::testing::IsNull;
using ::testing::Ne; using ::testing::Ne;
▲ Show 20 Lines • Show All 220 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, StructVarDeclWithInit) { TEST(TransferTest, StructVarDeclWithInit) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Bar; int Bar;
}; };
Show All 26 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ClassVarDecl) { TEST(TransferTest, ClassVarDecl) {
std::string Code = R"( std::string Code = R"(
class A { class A {
public: public:
int Bar; int Bar;
Show All 25 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ReferenceVarDecl) { TEST(TransferTest, ReferenceVarDecl) {
std::string Code = R"( std::string Code = R"(
struct A {}; struct A {};
A &getA(); A &getA();
▲ Show 20 Lines • Show All 658 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ReferenceParamDecl) { TEST(TransferTest, ReferenceParamDecl) {
std::string Code = R"( std::string Code = R"(
struct A {}; struct A {};
void target(A &Foo) { void target(A &Foo) {
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env)); cast<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env));
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
EXPECT_EQ(Env.getValue(*BazDecl), BarVal); EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
}); });
} }
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env)); cast<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env));
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
EXPECT_EQ(Env.getValue(*BazDecl), BarVal); EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
}); });
} }
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const auto *QuxLoc = const auto *QuxLoc =
cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl)); cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl));
const auto *QuxVal = dyn_cast<StructValue>(Env.getValue(*QuxLoc)); EXPECT_THAT(dyn_cast<StructValue>(Env.getValue(*QuxLoc)), NotNull());
ASSERT_THAT(QuxVal, NotNull());
const auto *BazLoc =
cast<ScalarStorageLocation>(QuxLoc->getChild(*BazDecl));
const auto *BazVal = const auto *BazVal =
cast<IntegerValue>(getFieldValue(QuxVal, *BazDecl, Env)); cast<IntegerValue>(getFieldValue(QuxLoc, *BazDecl, Env));
EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux"); const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
ASSERT_THAT(QuuxDecl, NotNull()); ASSERT_THAT(QuuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal); EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
}); });
} }
TEST(TransferTest, ClassThisMember) { TEST(TransferTest, ClassThisMember) {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const auto *QuxLoc = const auto *QuxLoc =
cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl)); cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl));
const auto *QuxVal = dyn_cast<StructValue>(Env.getValue(*QuxLoc)); EXPECT_THAT(dyn_cast<StructValue>(Env.getValue(*QuxLoc)), NotNull());
ASSERT_THAT(QuxVal, NotNull());
const auto *BazLoc =
cast<ScalarStorageLocation>(QuxLoc->getChild(*BazDecl));
const auto *BazVal = const auto *BazVal =
cast<IntegerValue>(getFieldValue(QuxVal, *BazDecl, Env)); cast<IntegerValue>(getFieldValue(QuxLoc, *BazDecl, Env));
EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux"); const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
ASSERT_THAT(QuuxDecl, NotNull()); ASSERT_THAT(QuuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal); EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
}); });
} }
TEST(TransferTest, UnionThisMember) { TEST(TransferTest, UnionThisMember) {
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines runDataflow(
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ElidableConstructor) { TEST(TransferTest, ElidableConstructor) {
// This test is effectively the same as TransferTest.TemporaryObject, but // This test is effectively the same as TransferTest.TemporaryObject, but
// the code is compiled as C++ 14. // the code is compiled as C++ 14.
std::string Code = R"( std::string Code = R"(
struct A { struct A {
Show All 16 Lines runDataflow(
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}, },
LangStandard::lang_cxx14); LangStandard::lang_cxx14);
} }
TEST(TransferTest, AssignmentOperator) { TEST(TransferTest, AssignmentOperator) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Baz; int Baz;
▲ Show 20 Lines • Show All 996 Lines • ▼ Show 20 Lines runDataflow(
} }
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>( const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>(
Env.getStorageLocation(*BazDecl)); Env.getStorageLocation(*BazDecl));
ASSERT_THAT(BazLoc, NotNull()); ASSERT_THAT(BazLoc, NotNull());
ASSERT_THAT(Env.getValue(*BazLoc), NotNull()); ASSERT_THAT(Env.getValue(*BazLoc), NotNull());
const auto *BazVal = cast<StructValue>(Env.getValue(*BazLoc)); const auto *FooVal =
const auto *FooValFromBazVal =
cast<IntegerValue>(getFieldValue(BazVal, *FooDecl, Env));
const auto *FooValFromBazLoc =
cast<IntegerValue>(getFieldValue(BazLoc, *FooDecl, Env)); cast<IntegerValue>(getFieldValue(BazLoc, *FooDecl, Env));
EXPECT_EQ(FooValFromBazLoc, FooValFromBazVal);
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarLoc = Env.getStorageLocation(*BarDecl); const auto *BarLoc = Env.getStorageLocation(*BarDecl);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
EXPECT_EQ(Env.getValue(*BarLoc), FooValFromBazVal); EXPECT_EQ(Env.getValue(*BarLoc), FooVal);
EXPECT_EQ(Env.getValue(*BarLoc), FooValFromBazLoc);
}); });
} }
TEST(TransferTest, AssignFromBoolLiteral) { TEST(TransferTest, AssignFromBoolLiteral) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
bool Foo = true; bool Foo = true;
bool Bar = false; bool Bar = false;
▲ Show 20 Lines • Show All 2,655 Lines • Show Last 20 Lines