This is an archive of the discontinued LLVM Phabricator instance.

Differential D63966

Add IsBytewiseValue unit test
ClosedPublic

Authored by vitalybuka on Jun 28 2019, 5:11 PM.

Details

Reviewers
eugenis
pcc
Commits
rG329d15b5df5c: Add IsBytewiseValue unit test
rL365710: Add IsBytewiseValue unit test

Diff Detail

Event Timeline

vitalybuka created this revision.Jun 28 2019, 5:11 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 28 2019, 5:11 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B34100: Diff 207179.Jun 28 2019, 5:11 PM
vitalybuka added a parent revision: D63940: NFC: Pass DataLayout into isBytewiseValue.Jun 28 2019, 5:12 PM
vitalybuka retitled this revision from Add IsBytewiseValueTest to Add IsBytewiseValue unit test.
vitalybuka added a child revision: D63967: Handle IntToPtr in isBytewiseValue.Jun 28 2019, 5:18 PM
vitalybuka added a reviewer: eugenis.
vitalybuka added a reviewer: pcc.Jun 28 2019, 5:20 PM
vitalybuka updated this revision to Diff 207447.Jul 1 2019, 5:55 PM

More tests

Harbormaster completed remote builds in B34170: Diff 207447.Jul 1 2019, 5:57 PM
vitalybuka updated this revision to Diff 207638.Jul 2 2019, 3:08 PM

More tests

Harbormaster completed remote builds in B34220: Diff 207638.Jul 2 2019, 3:10 PM
vitalybuka updated this revision to Diff 207661.Jul 2 2019, 4:51 PM

More tests

Harbormaster completed remote builds in B34229: Diff 207661.Jul 2 2019, 4:51 PM
vitalybuka updated this revision to Diff 207665.Jul 2 2019, 5:16 PM

More tests

Harbormaster completed remote builds in B34232: Diff 207665.Jul 2 2019, 5:17 PM
eugenis accepted this revision.Jul 10 2019, 2:30 PM

LGTM

This revision is now accepted and ready to land.Jul 10 2019, 2:30 PM
Closed by commit rL365710: Add IsBytewiseValue unit test (authored by vitalybuka). · Explain WhyJul 10 2019, 3:57 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
unittests/
Analysis/
250 lines

Diff 207447

llvm/unittests/Analysis/ValueTrackingTest.cpp

Show All 17 Lines
#include "gtest/gtest.h" #include "gtest/gtest.h"
using namespace llvm; using namespace llvm;
namespace { namespace {
class ValueTrackingTest : public testing::Test { class ValueTrackingTest : public testing::Test {
protected: protected:
void parseAssembly(const char *Assembly) { std::unique_ptr<Module> parseModule(StringRef Assembly) {
SMDiagnostic Error; SMDiagnostic Error;
M = parseAssemblyString(Assembly, Error, Context); std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
std::string errMsg; std::string errMsg;
raw_string_ostream os(errMsg); raw_string_ostream os(errMsg);
Error.print("", os); Error.print("", os);
EXPECT_TRUE(M) << os.str();
// A failure here means that the test itself is buggy. return M;
if (!M) }
report_fatal_error(os.str());
void parseAssembly(StringRef Assembly) {
M = parseModule(Assembly);
ASSERT_TRUE(M);
Function *F = M->getFunction("test"); Function *F = M->getFunction("test");
if (F == nullptr) ASSERT_TRUE(F) << "Test must have a function @test";
report_fatal_error("Test must have a function named @test"); if (!F)
return;
A = nullptr; A = nullptr;
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) { for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
if (I->hasName()) { if (I->hasName()) {
if (I->getName() == "A") if (I->getName() == "A")
A = &*I; A = &*I;
} }
} }
if (A == nullptr) ASSERT_TRUE(A) << "@test must have an instruction %A";
report_fatal_error("@test must have an instruction %A");
} }
LLVMContext Context; LLVMContext Context;
std::unique_ptr<Module> M; std::unique_ptr<Module> M;
Instruction *A; Instruction *A = nullptr;
}; };
class MatchSelectPatternTest : public ValueTrackingTest { class MatchSelectPatternTest : public ValueTrackingTest {
protected: protected:
void expectPattern(const SelectPatternResult &P) { void expectPattern(const SelectPatternResult &P) {
Value *LHS, *RHS; Value *LHS, *RHS;
Instruction::CastOps CastOp; Instruction::CastOps CastOp;
SelectPatternResult R = matchSelectPattern(A, LHS, RHS, &CastOp); SelectPatternResult R = matchSelectPattern(A, LHS, RHS, &CastOp);
▲ Show 20 Lines • Show All 620 Lines • ▼ Show 20 Lines parseAssembly(
" %bb = or i8 %b, 70\n" " %bb = or i8 %b, 70\n"
" %bbb = and i8 %bb, 254\n" " %bbb = and i8 %bb, 254\n"
" %A = call i8 @llvm.usub.sat.i8(i8 %aaa, i8 %bbb)\n" " %A = call i8 @llvm.usub.sat.i8(i8 %aaa, i8 %bbb)\n"
" ret i8 %A\n" " ret i8 %A\n"
"}\n" "}\n"
"declare i8 @llvm.usub.sat.i8(i8, i8)\n"); "declare i8 @llvm.usub.sat.i8(i8, i8)\n");
expectKnownBits(/*zero*/ 2u, /*one*/ 0u); expectKnownBits(/*zero*/ 2u, /*one*/ 0u);
} }
class IsBytewiseValueTest : public ValueTrackingTest,
public ::testing::WithParamInterface<
std::pair<const char *, const char *>> {
protected:
};
const std::pair<const char *, const char *> IsBytewiseValueTests[] = {
{
"i8 0",
"i8 zeroinitializer",
},
{
"i8 0",
"i8 0",
},
{
"i8 -86",
"i8 -86",
},
{
"i8 -1",
"i8 -1",
},
{
"i8 undef",
"i16 undef",
},
{
"i8 0",
"i48* null",
},
{
"i8 0",
"i16 0",
},
{
"",
"i16 7",
},
{
"i8 -86",
"i16 -21846",
},
{
"i8 -1",
"i16 -1",
},
{
"i8 0",
"half 0xH0000",
},
{
"i8 -85",
"half 0xHABAB",
},
{
"i8 0",
"float 0.0",
},
{
"i8 -1",
"float 0xFFFFFFFFE0000000",
},
{
"i8 0",
"double 0.0",
},
{
"i8 -15",
"double 0xF1F1F1F1F1F1F1F1",
},
{
"i8 undef",
"i16* undef",
},
{
"i8 0",
"i16* null",
},
{
"i8 0",
"i16* inttoptr (i64 0 to i16*)",
},
{
"",
"i16* inttoptr (i64 -1 to i16*)",
},
{
"",
"i16* inttoptr (i64 -6148914691236517206 to i16*)",
},
{
"",
"i16* inttoptr (i48 -1 to i16*)",
},
{
"",
"i16* inttoptr (i96 -1 to i16*)",
},
{
"i8 0",
"[0 x i8] zeroinitializer",
},
{
"i8 undef",
"[0 x i8] undef",
},
{
"i8 0",
"[6 x i8] zeroinitializer",
},
{
"i8 undef",
"[6 x i8] undef",
},
{
"i8 1",
"[5 x i8] [i8 1, i8 1, i8 1, i8 1, i8 1]",
},
{
"",
"[5 x i64] [i64 1, i64 1, i64 1, i64 1, i64 1]",
},
{
"i8 -1",
"[5 x i64] [i64 -1, i64 -1, i64 -1, i64 -1, i64 -1]",
},
{
"",
"[4 x i8] [i8 1, i8 2, i8 1, i8 1]",
},
{
"i8 1",
"[4 x i8] [i8 1, i8 undef, i8 1, i8 1]",
},
{
"i8 0",
"<6 x i8> zeroinitializer",
},
{
"i8 undef",
"<6 x i8> undef",
},
{
"i8 1",
"<5 x i8> <i8 1, i8 1, i8 1, i8 1, i8 1>",
},
{
"",
"<5 x i64> <i64 1, i64 1, i64 1, i64 1, i64 1>",
},
{
"i8 -1",
"<5 x i64> <i64 -1, i64 -1, i64 -1, i64 -1, i64 -1>",
},
{
"",
"<4 x i8> <i8 1, i8 1, i8 2, i8 1>",
},
{
"",
"<2 x i8> < i8 5, i8 undef >",
},
{
"i8 0",
"[2 x [2 x i16]] zeroinitializer",
},
{
"i8 undef",
"[2 x [2 x i16]] undef",
},
{
"i8 -86",
"[2 x [2 x i16]] [[2 x i16] [i16 -21846, i16 -21846], "
"[2 x i16] [i16 -21846, i16 -21846]]",
},
{
"",
"[2 x [2 x i16]] [[2 x i16] [i16 -21846, i16 -21846], "
"[2 x i16] [i16 -21836, i16 -21846]]",
},
{
"i8 0",
"{ } zeroinitializer",
},
{
"i8 undef",
"{ } undef",
},
{
"i8 0",
"{i8, i64, i16*} zeroinitializer",
},
{
"i8 undef",
"{i8, i64, i16*} undef",
},
{
"i8 -86",
"{i8, i64, i16*} {i8 -86, i64 -6148914691236517206, "
"i16* undef}",
},
{
"",
"{i8, i64, i16*} {i8 86, i64 -6148914691236517206, i16* undef}",
},
};
INSTANTIATE_TEST_CASE_P(IsBytewiseValueParamTests, IsBytewiseValueTest,
::testing::ValuesIn(IsBytewiseValueTests));
TEST_P(IsBytewiseValueTest, IsBytewiseValue) {
auto M = parseModule(std::string("@test = global ") + GetParam().second);
GlobalVariable *GV = dyn_cast<GlobalVariable>(M->getNamedValue("test"));
Value *Actual = isBytewiseValue(GV->getInitializer(), M->getDataLayout());
std::string Buff;
raw_string_ostream S(Buff);
if (Actual)
S << *Actual;
EXPECT_EQ(GetParam().first, S.str());
}