Skip to content

S
swiftshader
Commit cbb1d3d7 by Karl Schimpf
Options

Clean up unit munging unit tests using common NaCl API.

Simplify the munging unit tests to follow the new NaCl utilities for munging tests. Note that this CL takes advantage of changes added by CL https://codereview.chromium.org/1140153004 BUG=None R=stichnot@chromium.org Review URL: https://codereview.chromium.org/1149423011
parent 8af4aac7
Showing with 60 additions and 103 deletions
Makefile.standalone
...@@ -259,6 +259,7 @@ $(UNITTEST_OBJS): $(OBJDIR)/unittest/%.o: unittest/%.cpp \ ...@@ -259,6 +259,7 @@ $(UNITTEST_OBJS): $(OBJDIR)/unittest/%.o: unittest/%.cpp \
$(CXX) -c $(CXXFLAGS) \ $(CXX) -c $(CXXFLAGS) \
-Isrc/ \ -Isrc/ \
-I$(LLVM_SRC_PATH)/utils/unittest/googletest/include \ -I$(LLVM_SRC_PATH)/utils/unittest/googletest/include \
-I$(LLVM_SRC_PATH) \
-DGTEST_HAS_RTTI=0 -DGTEST_USE_OWN_TR1_TUPLE \ -DGTEST_HAS_RTTI=0 -DGTEST_USE_OWN_TR1_TUPLE \
$< -o $@ $< -o $@
......
unittest/BitcodeMunge.cpp
...@@ -33,14 +33,14 @@ void IceTest::SubzeroBitcodeMunger::resetMungeFlags() { ...@@ -33,14 +33,14 @@ void IceTest::SubzeroBitcodeMunger::resetMungeFlags() {
Flags.setVerbose(Ice::IceV_Instructions); Flags.setVerbose(Ice::IceV_Instructions);
} }
bool IceTest::SubzeroBitcodeMunger::runTest(const char *TestName, bool IceTest::SubzeroBitcodeMunger::runTest(const uint64_t Munges[],
const uint64_t Munges[],
size_t MungeSize) { size_t MungeSize) {
const bool AddHeader = true; const bool AddHeader = true;
setupTest(TestName, Munges, MungeSize, AddHeader); setupTest(Munges, MungeSize, AddHeader);
Ice::GlobalContext Ctx(DumpStream, DumpStream, DumpStream, nullptr, Flags); Ice::GlobalContext Ctx(DumpStream, DumpStream, DumpStream, nullptr, Flags);
Ice::PNaClTranslator Translator(&Ctx); Ice::PNaClTranslator Translator(&Ctx);
Translator.translateBuffer(TestName, MungedInput.get()); const char *BufferName = "Test";
Translator.translateBuffer(BufferName, MungedInput.get());
cleanupTest(); cleanupTest();
return Translator.getErrorStatus().value() == 0; return Translator.getErrorStatus().value() == 0;
......
unittest/BitcodeMunge.h
...@@ -36,12 +36,12 @@ public: ...@@ -36,12 +36,12 @@ public:
/// Runs PNaClTranslator to translate bitcode records (with defined /// Runs PNaClTranslator to translate bitcode records (with defined
/// record Munges), and puts output into DumpResults. Returns true /// record Munges), and puts output into DumpResults. Returns true
/// if parse is successful. /// if parse is successful.
bool runTest(const char *TestName, const uint64_t Munges[], size_t MungeSize); bool runTest(const uint64_t Munges[], size_t MungeSize);
/// Same as above, but without any edits. /// Same as above, but without any edits.
bool runTest(const char *TestName) { bool runTest() {
uint64_t NoMunges[] = {0}; uint64_t NoMunges[] = {0};
return runTest(TestName, NoMunges, 0); return runTest(NoMunges, 0);
} }
/// Sets flags back to default assumptions for munging. /// Sets flags back to default assumptions for munging.
......
unittest/IceParseInstsTest.cpp
...@@ -12,15 +12,13 @@ ...@@ -12,15 +12,13 @@
#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h" #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
#include "BitcodeMunge.h" #include "BitcodeMunge.h"
#include "unittests/Bitcode/NaClMungeTest.h"
#include "gtest/gtest.h"
using namespace llvm; using namespace llvm;
using namespace naclmungetest;
namespace { namespace {
static const uint64_t Terminator = 0x5768798008978675LL;
// Note: alignment stored as 0 or log2(Alignment)+1. // Note: alignment stored as 0 or log2(Alignment)+1.
uint64_t getEncAlignPower(unsigned Power) { uint64_t getEncAlignPower(unsigned Power) {
return Power + 1; return Power + 1;
...@@ -49,26 +47,22 @@ TEST(IceParseInstsTest, NonexistentCallArg) { ...@@ -49,26 +47,22 @@ TEST(IceParseInstsTest, NonexistentCallArg) {
}; };
// Show bitcode objdump for BitcodeRecords. // Show bitcode objdump for BitcodeRecords.
NaClObjDumpMunger DumpMunger(BitcodeRecords, NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords));
array_lengthof(BitcodeRecords), Terminator); EXPECT_FALSE(DumpMunger.runTest());
EXPECT_FALSE(DumpMunger.runTest("Nonexistent call arg"));
EXPECT_EQ(" 66:4| 3: <34, 0, 4, 2, 100> | call void @f0(i32 " EXPECT_EQ(" 66:4| 3: <34, 0, 4, 2, 100> | call void @f0(i32 "
"%p0, i32 @f0);\n" "%p0, i32 @f0);\n"
"Error(66:4): Invalid relative value id: 100 (Must be <= 4)\n", "Error(66:4): Invalid relative value id: 100 (Must be <= 4)\n",
DumpMunger.getLinesWithSubstring("66:4")); DumpMunger.getLinesWithSubstring("66:4"));
// Show that we get appropriate error when parsing in Subzero. // Show that we get appropriate error when parsing in Subzero.
IceTest::SubzeroBitcodeMunger Munger( IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); EXPECT_FALSE(Munger.runTest());
EXPECT_FALSE(Munger.runTest("Nonexistent call arg"));
EXPECT_EQ("Error(66:4): Invalid function record: <34 0 4 2 100>\n", EXPECT_EQ("Error(66:4): Invalid function record: <34 0 4 2 100>\n",
Munger.getTestResults()); Munger.getTestResults());
// Show that we generate a fatal error when not allowing error recovery. // Show that we generate a fatal error when not allowing error recovery.
Munger.Flags.setAllowErrorRecovery(false); Munger.Flags.setAllowErrorRecovery(false);
EXPECT_DEATH( EXPECT_DEATH(Munger.runTest(), ".*ERROR: Unable to continue.*");
Munger.runTest("Nonexistent call arg"),
".*ERROR: Unable to continue.*");
} }
/// Test how we recognize alignments in alloca instructions. /// Test how we recognize alignments in alloca instructions.
...@@ -93,27 +87,23 @@ TEST(IceParseInstsTests, AllocaAlignment) { ...@@ -93,27 +87,23 @@ TEST(IceParseInstsTests, AllocaAlignment) {
const uint64_t ReplaceIndex = 11; // index for FUNC_CODE_INST_ALLOCA const uint64_t ReplaceIndex = 11; // index for FUNC_CODE_INST_ALLOCA
// Show text when alignment is 1. // Show text when alignment is 1.
NaClObjDumpMunger DumpMunger(BitcodeRecords, array_lengthof(BitcodeRecords), NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords));
Terminator); EXPECT_TRUE(DumpMunger.runTest());
EXPECT_TRUE(DumpMunger.runTest("Good alloca alignment 1"));
EXPECT_EQ(" 62:4| 3: <19, 1, 1> | %v0 = alloca i8, i32 " EXPECT_EQ(" 62:4| 3: <19, 1, 1> | %v0 = alloca i8, i32 "
"%p0, align 1;\n", "%p0, align 1;\n",
DumpMunger.getLinesWithSubstring("62:4")); DumpMunger.getLinesWithSubstring("62:4"));
// Show that we can handle alignment of 1. // Show that we can handle alignment of 1.
IceTest::SubzeroBitcodeMunger Munger( IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); EXPECT_TRUE(Munger.runTest());
EXPECT_TRUE(Munger.runTest("Good alloca alignment 1"));
// Show what happens when changing alignment to 0. // Show what happens when changing alignment to 0.
const uint64_t Align0[] = { const uint64_t Align0[] = {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignZero(), Terminator, 3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignZero(), Terminator,
}; };
EXPECT_TRUE(Munger.runTest("Good alloca alignment 0", Align0, EXPECT_TRUE(Munger.runTest(ARRAY(Align0)));
array_lengthof(Align0))); EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
EXPECT_TRUE(DumpMunger.runTestForAssembly("Good alloca alignment 0", Align0,
array_lengthof(Align0)));
EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n", EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n",
DumpMunger.getLinesWithSubstring("alloca")); DumpMunger.getLinesWithSubstring("alloca"));
...@@ -122,13 +112,11 @@ TEST(IceParseInstsTests, AllocaAlignment) { ...@@ -122,13 +112,11 @@ TEST(IceParseInstsTests, AllocaAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(30), Terminator, 3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(30), Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad alloca alignment 30", Align30, EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n", EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad alloca alignment 30", Align30, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n", EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n",
DumpMunger.getLinesWithSubstring("alloca")); DumpMunger.getLinesWithSubstring("alloca"));
EXPECT_EQ( EXPECT_EQ(
...@@ -140,10 +128,8 @@ TEST(IceParseInstsTests, AllocaAlignment) { ...@@ -140,10 +128,8 @@ TEST(IceParseInstsTests, AllocaAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(29), Terminator, 3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(29), Terminator,
}; };
EXPECT_TRUE(Munger.runTest("Good alloca alignment 29", Align29, EXPECT_TRUE(Munger.runTest(ARRAY(Align29)));
array_lengthof(Align29))); EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
EXPECT_TRUE(DumpMunger.runTestForAssembly("Good alloca alignment 29", Align29,
array_lengthof(Align29)));
EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 536870912;\n", EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 536870912;\n",
DumpMunger.getLinesWithSubstring("alloca")); DumpMunger.getLinesWithSubstring("alloca"));
} }
...@@ -168,27 +154,23 @@ TEST(IceParseInstsTests, LoadI32Alignment) { ...@@ -168,27 +154,23 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
const uint64_t ReplaceIndex = 9; // index for FUNC_CODE_INST_LOAD const uint64_t ReplaceIndex = 9; // index for FUNC_CODE_INST_LOAD
// Show text when alignment is 1. // Show text when alignment is 1.
NaClObjDumpMunger DumpMunger(BitcodeRecords, array_lengthof(BitcodeRecords), NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords));
Terminator); EXPECT_TRUE(DumpMunger.runTest());
EXPECT_TRUE(DumpMunger.runTest("Good load i32 alignment 1"));
EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load i32* %p0, " EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load i32* %p0, "
"align 1;\n", "align 1;\n",
DumpMunger.getLinesWithSubstring("58:4")); DumpMunger.getLinesWithSubstring("58:4"));
IceTest::SubzeroBitcodeMunger Munger( IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); EXPECT_TRUE(Munger.runTest());
EXPECT_TRUE(Munger.runTest("Good load i32 alignment 1"));
// Show what happens when changing alignment to 0. // Show what happens when changing alignment to 0.
const uint64_t Align0[] = { const uint64_t Align0[] = {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 0", Align0, EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
array_lengthof(Align0)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 0", Align0, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
array_lengthof(Align0)));
EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n" EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n"
"Error(58:4): load: Illegal alignment for i32. Expects: 1\n", "Error(58:4): load: Illegal alignment for i32. Expects: 1\n",
DumpMunger.getLinesWithSubstring("load")); DumpMunger.getLinesWithSubstring("load"));
...@@ -198,12 +180,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) { ...@@ -198,12 +180,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 4", Align4, EXPECT_FALSE(Munger.runTest(ARRAY(Align4)));
array_lengthof(Align4)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 4", Align4, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align4)));
array_lengthof(Align4)));
EXPECT_EQ(" %v0 = load i32* %p0, align 4;\n" EXPECT_EQ(" %v0 = load i32* %p0, align 4;\n"
"Error(58:4): load: Illegal alignment for i32. Expects: 1\n", "Error(58:4): load: Illegal alignment for i32. Expects: 1\n",
DumpMunger.getLinesWithSubstring("load")); DumpMunger.getLinesWithSubstring("load"));
...@@ -213,12 +193,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) { ...@@ -213,12 +193,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 29", Align29, EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
array_lengthof(Align29)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 29", EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
Align29, array_lengthof(Align29)));
EXPECT_EQ(" %v0 = load i32* %p0, align 536870912;\n" EXPECT_EQ(" %v0 = load i32* %p0, align 536870912;\n"
"Error(58:4): load: Illegal alignment for i32. Expects: 1\n", "Error(58:4): load: Illegal alignment for i32. Expects: 1\n",
DumpMunger.getLinesWithSubstring("load")); DumpMunger.getLinesWithSubstring("load"));
...@@ -228,12 +206,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) { ...@@ -228,12 +206,10 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 30", Align30, EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 30", EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
Align30, array_lengthof(Align30)));
EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n" EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n"
"Error(58:4): load: Illegal alignment for i32. Expects: 1\n", "Error(58:4): load: Illegal alignment for i32. Expects: 1\n",
DumpMunger.getLinesWithSubstring("load")); DumpMunger.getLinesWithSubstring("load"));
...@@ -260,27 +236,23 @@ TEST(IceParseInstsTests, LoadFloatAlignment) { ...@@ -260,27 +236,23 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
const uint64_t ReplaceIndex = 10; // index for FUNC_CODE_INST_LOAD const uint64_t ReplaceIndex = 10; // index for FUNC_CODE_INST_LOAD
// Show text when alignment is 1. // Show text when alignment is 1.
NaClObjDumpMunger DumpMunger(BitcodeRecords, array_lengthof(BitcodeRecords), NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords));
Terminator); EXPECT_TRUE(DumpMunger.runTest());
EXPECT_TRUE(DumpMunger.runTest("Good load float alignment 1"));
EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load float* " EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load float* "
"%p0, align 1;\n", "%p0, align 1;\n",
DumpMunger.getLinesWithSubstring("58:4")); DumpMunger.getLinesWithSubstring("58:4"));
IceTest::SubzeroBitcodeMunger Munger( IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); EXPECT_TRUE(Munger.runTest());
EXPECT_TRUE(Munger.runTest("Good load float alignment 1"));
// Show what happens when changing alignment to 0. // Show what happens when changing alignment to 0.
const uint64_t Align0[] = { const uint64_t Align0[] = {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load float alignment 0", Align0, EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
array_lengthof(Align0)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 0", EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
Align0, array_lengthof(Align0)));
EXPECT_EQ( EXPECT_EQ(
" %v0 = load float* %p0, align 0;\n" " %v0 = load float* %p0, align 0;\n"
"Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -291,10 +263,8 @@ TEST(IceParseInstsTests, LoadFloatAlignment) { ...@@ -291,10 +263,8 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator,
}; };
EXPECT_TRUE(Munger.runTest("Good load float alignment 4", Align4, EXPECT_TRUE(Munger.runTest(ARRAY(Align4)));
array_lengthof(Align4))); EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align4)));
EXPECT_TRUE(DumpMunger.runTestForAssembly("Good load float alignment 4",
Align4, array_lengthof(Align4)));
EXPECT_EQ(" %v0 = load float* %p0, align 4;\n", EXPECT_EQ(" %v0 = load float* %p0, align 4;\n",
DumpMunger.getLinesWithSubstring("load")); DumpMunger.getLinesWithSubstring("load"));
...@@ -302,12 +272,10 @@ TEST(IceParseInstsTests, LoadFloatAlignment) { ...@@ -302,12 +272,10 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load float alignment 29", Align29, EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
array_lengthof(Align29)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 29", EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
Align29, array_lengthof(Align29)));
EXPECT_EQ( EXPECT_EQ(
" %v0 = load float* %p0, align 536870912;\n" " %v0 = load float* %p0, align 536870912;\n"
"Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -318,12 +286,10 @@ TEST(IceParseInstsTests, LoadFloatAlignment) { ...@@ -318,12 +286,10 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator, 3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad load float alignment 30", Align30, EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n", EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 30", EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
Align30, array_lengthof(Align30)));
EXPECT_EQ( EXPECT_EQ(
" %v0 = load float* %p0, align 0;\n" " %v0 = load float* %p0, align 0;\n"
"Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -359,19 +325,17 @@ TEST(NaClParseInstsTests, StoreAlignment) { ...@@ -359,19 +325,17 @@ TEST(NaClParseInstsTests, StoreAlignment) {
DumpMunger.getLinesWithSubstring("62:4")); DumpMunger.getLinesWithSubstring("62:4"));
IceTest::SubzeroBitcodeMunger Munger( IceTest::SubzeroBitcodeMunger Munger(
BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); BitcodeRecords, array_lengthof(BitcodeRecords), Terminator);
EXPECT_TRUE(Munger.runTest("Good store alignment")); EXPECT_TRUE(Munger.runTest());
// Show what happens when changing alignment to 0. // Show what happens when changing alignment to 0.
const uint64_t Align0[] = { const uint64_t Align0[] = {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignZero(), Terminator, 3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignZero(), Terminator,
}; };
EXPECT_FALSE( EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
Munger.runTest("Bad store alignment 0", Align0, array_lengthof(Align0)));
EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n", EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 0", Align0, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
array_lengthof(Align0)));
EXPECT_EQ( EXPECT_EQ(
" store float %p1, float* %p0, align 0;\n" " store float %p1, float* %p0, align 0;\n"
"Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -382,22 +346,18 @@ TEST(NaClParseInstsTests, StoreAlignment) { ...@@ -382,22 +346,18 @@ TEST(NaClParseInstsTests, StoreAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(2), Terminator, 3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(2), Terminator,
}; };
EXPECT_TRUE( EXPECT_TRUE(Munger.runTest(ARRAY(Align4)));
Munger.runTest("Bad store alignment 4", Align4, array_lengthof(Align4))); EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align4)));
EXPECT_TRUE(DumpMunger.runTestForAssembly("Good store alignment 4", Align4,
array_lengthof(Align4)));
// Show what happens when changing alignment to 8. // Show what happens when changing alignment to 8.
const uint64_t Align8[] = { const uint64_t Align8[] = {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(3), Terminator, 3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(3), Terminator,
}; };
EXPECT_FALSE( EXPECT_FALSE(Munger.runTest(ARRAY(Align8)));
Munger.runTest("Bad store alignment 8", Align8, array_lengthof(Align8)));
EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n", EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 8", Align8, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align8)));
array_lengthof(Align8)));
EXPECT_EQ( EXPECT_EQ(
" store float %p1, float* %p0, align 8;\n" " store float %p1, float* %p0, align 8;\n"
"Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -408,12 +368,10 @@ TEST(NaClParseInstsTests, StoreAlignment) { ...@@ -408,12 +368,10 @@ TEST(NaClParseInstsTests, StoreAlignment) {
ReplaceIndex, NaClMungedBitcode::Replace, ReplaceIndex, NaClMungedBitcode::Replace,
3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(29), Terminator, 3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(29), Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad store alignment 29", Align29, EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
array_lengthof(Align29)));
EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n", EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 29", Align29, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
array_lengthof(Align29)));
EXPECT_EQ( EXPECT_EQ(
" store float %p1, float* %p0, align 536870912;\n" " store float %p1, float* %p0, align 536870912;\n"
"Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n",
...@@ -424,12 +382,10 @@ TEST(NaClParseInstsTests, StoreAlignment) { ...@@ -424,12 +382,10 @@ TEST(NaClParseInstsTests, StoreAlignment) {
// Note: alignment stored as 0 or log2(Alignment)+1. // Note: alignment stored as 0 or log2(Alignment)+1.
3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(30), Terminator, 3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(30), Terminator,
}; };
EXPECT_FALSE(Munger.runTest("Bad store alignment 30", Align30, EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n", EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n",
Munger.getTestResults()); Munger.getTestResults());
EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad Store alignment 30", Align30, EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
array_lengthof(Align30)));
EXPECT_EQ( EXPECT_EQ(
" store float %p1, float* %p0, align 0;\n" " store float %p1, float* %p0, align 0;\n"
"Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment