| //===- unittest/IceParseInstsTest.cpp - test instruction errors -----------===// | |
| // | |
| // The Subzero Code Generator | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include <string> | |
| #pragma clang diagnostic push | |
| #pragma clang diagnostic ignored "-Wunused-parameter" | |
| #include "llvm/ADT/STLExtras.h" | |
| #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" | |
| #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h" | |
| #pragma clang diagnostic pop | |
| #include "BitcodeMunge.h" | |
| #include "unittests/Bitcode/NaClMungeTest.h" | |
| using namespace llvm; | |
| using namespace naclmungetest; | |
| namespace { | |
| // The ParseError constant is passed to the BitcodeMunger to prevent translation | |
| // when we expect a Parse error. | |
| constexpr bool ParseError = true; | |
| // Note: alignment stored as 0 or log2(Alignment)+1. | |
| uint64_t getEncAlignPower(unsigned Power) { return Power + 1; } | |
| uint64_t getEncAlignZero() { return 0; } | |
| /// Test how we report a call arg that refers to nonexistent call argument | |
| TEST(IceParseInstsTest, NonexistentCallArg) { | |
| const uint64_t BitcodeRecords[] = { | |
| 1, naclbitc::BLK_CODE_ENTER, naclbitc::MODULE_BLOCK_ID, 2, Terminator, 1, | |
| naclbitc::BLK_CODE_ENTER, naclbitc::TYPE_BLOCK_ID_NEW, 2, Terminator, 3, | |
| naclbitc::TYPE_CODE_NUMENTRY, 3, Terminator, 3, | |
| naclbitc::TYPE_CODE_INTEGER, 32, Terminator, 3, naclbitc::TYPE_CODE_VOID, | |
| Terminator, 3, naclbitc::TYPE_CODE_FUNCTION, 0, 1, 0, 0, Terminator, 0, | |
| naclbitc::BLK_CODE_EXIT, Terminator, 3, naclbitc::MODULE_CODE_FUNCTION, 2, | |
| 0, 1, 3, Terminator, 3, naclbitc::MODULE_CODE_FUNCTION, 2, 0, 0, 3, | |
| Terminator, 1, naclbitc::BLK_CODE_ENTER, naclbitc::FUNCTION_BLOCK_ID, 2, | |
| Terminator, 3, naclbitc::FUNC_CODE_DECLAREBLOCKS, 1, Terminator, | |
| // Note: 100 is a bad value index in next line. | |
| 3, naclbitc::FUNC_CODE_INST_CALL, 0, 4, 2, 100, Terminator, 3, | |
| naclbitc::FUNC_CODE_INST_RET, Terminator, 0, naclbitc::BLK_CODE_EXIT, | |
| Terminator, 0, naclbitc::BLK_CODE_EXIT, Terminator}; | |
| // Show bitcode objdump for BitcodeRecords. | |
| NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_FALSE(DumpMunger.runTest()); | |
| EXPECT_EQ(" 66:4| 3: <34, 0, 4, 2, 100> | call void @f0(i32 " | |
| "%p0, i32 @f0);\n" | |
| "Error(66:4): Invalid relative value id: 100 (Must be <= 4)\n", | |
| DumpMunger.getLinesWithSubstring("66:4")); | |
| // Show that we get appropriate error when parsing in Subzero. | |
| IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_FALSE(Munger.runTest(ParseError)); | |
| EXPECT_EQ("Error(66:4): Invalid function record: <34 0 4 2 100>\n", | |
| Munger.getTestResults()); | |
| // Show that we generate a fatal error when not allowing error recovery. | |
| Ice::ClFlags::Flags.setAllowErrorRecovery(false); | |
| EXPECT_DEATH(Munger.runTest(ParseError), ".*ERROR: Unable to continue.*"); | |
| } | |
| /// Test how we recognize alignments in alloca instructions. | |
| TEST(IceParseInstsTests, AllocaAlignment) { | |
| const uint64_t BitcodeRecords[] = {1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::MODULE_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::TYPE_BLOCK_ID_NEW, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_NUMENTRY, | |
| 4, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_INTEGER, | |
| 32, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_VOID, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FUNCTION, | |
| 0, | |
| 1, | |
| 0, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_INTEGER, | |
| 8, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 3, | |
| naclbitc::MODULE_CODE_FUNCTION, | |
| 2, | |
| 0, | |
| 0, | |
| 3, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::FUNCTION_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_DECLAREBLOCKS, | |
| 1, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_ALLOCA, | |
| 1, | |
| getEncAlignPower(0), | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_RET, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator}; | |
| const uint64_t ReplaceIndex = 11; // index for FUNC_CODE_INST_ALLOCA | |
| // Show text when alignment is 1. | |
| NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(DumpMunger.runTest()); | |
| EXPECT_EQ(" 62:4| 3: <19, 1, 1> | %v0 = alloca i8, i32 " | |
| "%p0, align 1;\n", | |
| DumpMunger.getLinesWithSubstring("62:4")); | |
| // Show that we can handle alignment of 1. | |
| IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(Munger.runTest()); | |
| // Show what happens when changing alignment to 0. | |
| const uint64_t Align0[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_ALLOCA, | |
| 1, | |
| getEncAlignZero(), | |
| Terminator, | |
| }; | |
| EXPECT_TRUE(Munger.runTest(ARRAY(Align0))); | |
| EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align0))); | |
| EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n", | |
| DumpMunger.getLinesWithSubstring("alloca")); | |
| // Show what happens when changing alignment to 2**30. | |
| const uint64_t Align30[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_ALLOCA, | |
| 1, | |
| getEncAlignPower(30), | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError)); | |
| EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30))); | |
| EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 0;\n", | |
| DumpMunger.getLinesWithSubstring("alloca")); | |
| EXPECT_EQ( | |
| "Error(62:4): Alignment can't be greater than 2**29. Found: 2**30\n", | |
| DumpMunger.getLinesWithSubstring("Error")); | |
| // Show what happens when changing alignment to 2**29. | |
| const uint64_t Align29[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_ALLOCA, | |
| 1, | |
| getEncAlignPower(29), | |
| Terminator, | |
| }; | |
| EXPECT_TRUE(Munger.runTest(ARRAY(Align29))); | |
| EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align29))); | |
| EXPECT_EQ(" %v0 = alloca i8, i32 %p0, align 536870912;\n", | |
| DumpMunger.getLinesWithSubstring("alloca")); | |
| } | |
| // Test how we recognize alignments in load i32 instructions. | |
| TEST(IceParseInstsTests, LoadI32Alignment) { | |
| const uint64_t BitcodeRecords[] = {1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::MODULE_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::TYPE_BLOCK_ID_NEW, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_NUMENTRY, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_INTEGER, | |
| 32, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FUNCTION, | |
| 0, | |
| 0, | |
| 0, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 3, | |
| naclbitc::MODULE_CODE_FUNCTION, | |
| 1, | |
| 0, | |
| 0, | |
| 3, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::FUNCTION_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_DECLAREBLOCKS, | |
| 1, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(0), | |
| 0, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_RET, | |
| 1, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator}; | |
| const uint64_t ReplaceIndex = 9; // index for FUNC_CODE_INST_LOAD | |
| // Show text when alignment is 1. | |
| NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(DumpMunger.runTest()); | |
| EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load i32* %p0, " | |
| "align 1;\n", | |
| DumpMunger.getLinesWithSubstring("58:4")); | |
| IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(Munger.runTest()); | |
| // Show what happens when changing alignment to 0. | |
| const uint64_t Align0[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignZero(), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0))); | |
| EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n" | |
| "Error(58:4): load: Illegal alignment for i32. Expects: 1\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| // Show what happens when changing alignment to 4. | |
| const uint64_t Align4[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(2), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align4), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align4))); | |
| EXPECT_EQ(" %v0 = load i32* %p0, align 4;\n" | |
| "Error(58:4): load: Illegal alignment for i32. Expects: 1\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| // Show what happens when changing alignment to 2**29. | |
| const uint64_t Align29[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(29), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29))); | |
| EXPECT_EQ(" %v0 = load i32* %p0, align 536870912;\n" | |
| "Error(58:4): load: Illegal alignment for i32. Expects: 1\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| // Show what happens when changing alignment to 2**30. | |
| const uint64_t Align30[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(30), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30))); | |
| EXPECT_EQ(" %v0 = load i32* %p0, align 0;\n" | |
| "Error(58:4): load: Illegal alignment for i32. Expects: 1\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| } | |
| // Test how we recognize alignments in load float instructions. | |
| TEST(IceParseInstsTests, LoadFloatAlignment) { | |
| const uint64_t BitcodeRecords[] = {1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::MODULE_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::TYPE_BLOCK_ID_NEW, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_NUMENTRY, | |
| 3, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FLOAT, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_INTEGER, | |
| 32, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FUNCTION, | |
| 0, | |
| 0, | |
| 1, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 3, | |
| naclbitc::MODULE_CODE_FUNCTION, | |
| 2, | |
| 0, | |
| 0, | |
| 3, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::FUNCTION_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_DECLAREBLOCKS, | |
| 1, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(0), | |
| 0, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_RET, | |
| 1, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator}; | |
| const uint64_t ReplaceIndex = 10; // index for FUNC_CODE_INST_LOAD | |
| // Show text when alignment is 1. | |
| NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(DumpMunger.runTest()); | |
| EXPECT_EQ(" 58:4| 3: <20, 1, 1, 0> | %v0 = load float* " | |
| "%p0, align 1;\n", | |
| DumpMunger.getLinesWithSubstring("58:4")); | |
| IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords)); | |
| EXPECT_TRUE(Munger.runTest()); | |
| // Show what happens when changing alignment to 0. | |
| const uint64_t Align0[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignZero(), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0))); | |
| EXPECT_EQ(" %v0 = load float* %p0, align 0;\n" | |
| "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| // Show what happens when changing alignment to 4. | |
| const uint64_t Align4[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(2), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_TRUE(Munger.runTest(ARRAY(Align4))); | |
| EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align4))); | |
| EXPECT_EQ(" %v0 = load float* %p0, align 4;\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| const uint64_t Align29[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(29), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29))); | |
| EXPECT_EQ(" %v0 = load float* %p0, align 536870912;\n" | |
| "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| // Show what happens when changing alignment to 2**30. | |
| const uint64_t Align30[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_LOAD, | |
| 1, | |
| getEncAlignPower(30), | |
| 0, | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError)); | |
| EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30))); | |
| EXPECT_EQ(" %v0 = load float* %p0, align 0;\n" | |
| "Error(58:4): load: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("load")); | |
| } | |
| // Test how we recognize alignments in store instructions. | |
| TEST(NaClParseInstsTests, StoreAlignment) { | |
| const uint64_t BitcodeRecords[] = {1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::MODULE_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::TYPE_BLOCK_ID_NEW, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_NUMENTRY, | |
| 3, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FLOAT, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_INTEGER, | |
| 32, | |
| Terminator, | |
| 3, | |
| naclbitc::TYPE_CODE_FUNCTION, | |
| 0, | |
| 0, | |
| 1, | |
| 0, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 3, | |
| naclbitc::MODULE_CODE_FUNCTION, | |
| 2, | |
| 0, | |
| 0, | |
| 3, | |
| Terminator, | |
| 1, | |
| naclbitc::BLK_CODE_ENTER, | |
| naclbitc::FUNCTION_BLOCK_ID, | |
| 2, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_DECLAREBLOCKS, | |
| 1, | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignPower(0), | |
| Terminator, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_RET, | |
| 1, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator, | |
| 0, | |
| naclbitc::BLK_CODE_EXIT, | |
| Terminator}; | |
| const uint64_t ReplaceIndex = 10; // index for FUNC_CODE_INST_STORE | |
| // Show text when alignment is 1. | |
| NaClObjDumpMunger DumpMunger(BitcodeRecords, array_lengthof(BitcodeRecords), | |
| Terminator); | |
| EXPECT_TRUE(DumpMunger.runTest("Good Store Alignment 1")); | |
| EXPECT_EQ(" 62:4| 3: <24, 2, 1, 1> | store float %p1, " | |
| "float* %p0, \n", | |
| DumpMunger.getLinesWithSubstring("62:4")); | |
| IceTest::SubzeroBitcodeMunger Munger( | |
| BitcodeRecords, array_lengthof(BitcodeRecords), Terminator); | |
| EXPECT_TRUE(Munger.runTest()); | |
| // Show what happens when changing alignment to 0. | |
| const uint64_t Align0[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignZero(), | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError)); | |
| EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0))); | |
| EXPECT_EQ( | |
| " store float %p1, float* %p0, align 0;\n" | |
| "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("store")); | |
| // Show what happens when changing alignment to 4. | |
| const uint64_t Align4[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignPower(2), | |
| Terminator, | |
| }; | |
| EXPECT_TRUE(Munger.runTest(ARRAY(Align4))); | |
| EXPECT_TRUE(DumpMunger.runTestForAssembly(ARRAY(Align4))); | |
| // Show what happens when changing alignment to 8. | |
| const uint64_t Align8[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignPower(3), | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align8), ParseError)); | |
| EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align8))); | |
| EXPECT_EQ( | |
| " store float %p1, float* %p0, align 8;\n" | |
| "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("store")); | |
| // Show what happens when changing alignment to 2**29. | |
| const uint64_t Align29[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignPower(29), | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError)); | |
| EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29))); | |
| EXPECT_EQ( | |
| " store float %p1, float* %p0, align 536870912;\n" | |
| "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("store")); | |
| const uint64_t Align30[] = { | |
| ReplaceIndex, | |
| NaClMungedBitcode::Replace, | |
| // Note: alignment stored as 0 or log2(Alignment)+1. | |
| 3, | |
| naclbitc::FUNC_CODE_INST_STORE, | |
| 2, | |
| 1, | |
| getEncAlignPower(30), | |
| Terminator, | |
| }; | |
| EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError)); | |
| EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n", | |
| Munger.getTestResults()); | |
| EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30))); | |
| EXPECT_EQ( | |
| " store float %p1, float* %p0, align 0;\n" | |
| "Error(62:4): store: Illegal alignment for float. Expects: 1 or 4\n", | |
| DumpMunger.getLinesWithSubstring("store")); | |
| } | |
| } // end of anonymous namespace |