Unittest fixes.

unittest/IceParseInstsTest.cpp

 //===- 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 "llvm/ADT/STLExtras.h"
@@ skipping 38 matching lines @@
   // 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());

[Karl, 2015/06/11 19:58:54]

Why not add an (optional) flag to runTest() in (unittest/BitcodeMunge.h) to
disable translation. Then, for cases with parse errors, pass in the disable flag
as an argument. This should keep from having to add this (unconditional) code to
results returned by getTestResults().

[John, 2015/06/11 20:42:09]

There was precedent to doing this (e.g., lines 52-55.) Thanks for the
suggestion.

-  EXPECT_EQ("Error(66:4): Invalid function record: <34 0 4 2 100>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"

[Jim Stichnoth, 2015/06/11 19:07:14]

Can you factor this string into a const char *, or a macro if necessary?

[John, 2015/06/11 20:42:09]

Not easily. EXPECT_EQ expands to another another macro, and macro substitution
is limited to two (?)... Anyway, I added the ParseError parameter, so this no
longer applies.

+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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.
   Munger.Flags.setAllowErrorRecovery(false);
   EXPECT_DEATH(Munger.runTest(), ".*ERROR: Unable to continue.*");
 }
 
 /// Test how we recognize alignments in alloca instructions.
 TEST(IceParseInstsTests, AllocaAlignment) {
   const uint64_t BitcodeRecords[] = {
@@ skipping 35 matching lines @@
   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)));
-  EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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.
@@ skipping 34 matching lines @@
             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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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[] = {
@@ skipping 22 matching lines @@
             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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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) {
@@ skipping 25 matching lines @@
   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)));
-  EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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)));
-  EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n",
+  EXPECT_EQ("\t.type\t__Sz_block_profile_info,@object\n"
+            "\t.section\t.rodata,\"a\",@progbits\n"
+            "\t.globl\t__Sz_block_profile_info\n"
+            "\t.align\t8"
+            "\n__Sz_block_profile_info:\n"
+                "\t.zero\t8\n"
+                "\t.size\t__Sz_block_profile_info, 8\n"
+            "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