Fix instruction unit tests to use new editing constants.

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 89 matching lines @@
             "%p0, align 1;\n",
             DumpMunger.getLinesWithSubstring("62:4"));
 
   // Show that we can handle alignment of 1.
   IceTest::SubzeroBitcodeMunger Munger(
       BitcodeRecords, array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("Good alloca alignment 1"));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignZero(), Terminator,
   };
   EXPECT_TRUE(Munger.runTest("Good alloca alignment 0", Align0,
                              array_lengthof(Align0)));
   EXPECT_TRUE(DumpMunger.runTestForAssembly("Good alloca alignment 0", Align0,
                                             array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(30), Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad alloca alignment 30", Align30,
                               array_lengthof(Align30)));
   EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n",
             Munger.getTestResults());
 
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad alloca alignment 30", Align30,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(29), Terminator,
   };
   EXPECT_TRUE(Munger.runTest("Good alloca alignment 29", Align29,
                              array_lengthof(Align29)));
   EXPECT_TRUE(DumpMunger.runTestForAssembly("Good alloca alignment 29", Align29,
                                             array_lengthof(Align29)));
   EXPECT_EQ("    %v0 = alloca i8, i32 %p0, align 536870912;\n",
             DumpMunger.getLinesWithSubstring("alloca"));
 }
 
@@ skipping 22 matching lines @@
   EXPECT_TRUE(DumpMunger.runTest("Good load i32 alignment 1"));
   EXPECT_EQ("      58:4|    3: <20, 1, 1, 0>         |    %v0 = load i32* %p0, "
             "align 1;\n",
             DumpMunger.getLinesWithSubstring("58:4"));
   IceTest::SubzeroBitcodeMunger Munger(
       BitcodeRecords, array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("Good load i32 alignment 1"));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 0", Align0,
                               array_lengthof(Align0)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 0", Align0,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 4", Align4,
                               array_lengthof(Align4)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 4", Align4,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 29", Align29,
                               array_lengthof(Align29)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 29",
                                              Align29, array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load i32 alignment 30", Align30,
                               array_lengthof(Align30)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load i32 alignment 30",
                                              Align30, array_lengthof(Align30)));
   EXPECT_EQ("    %v0 = load i32* %p0, align 0;\n"
             "Error(58:4): load: Illegal alignment for i32. Expects: 1\n",
@@ skipping 26 matching lines @@
   EXPECT_TRUE(DumpMunger.runTest("Good load float alignment 1"));
   EXPECT_EQ("      58:4|    3: <20, 1, 1, 0>         |    %v0 = load float* "
             "%p0, align 1;\n",
             DumpMunger.getLinesWithSubstring("58:4"));
   IceTest::SubzeroBitcodeMunger Munger(
       BitcodeRecords, array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("Good load float alignment 1"));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load float alignment 0", Align0,
                               array_lengthof(Align0)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 0",
                                              Align0, array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator,
   };
   EXPECT_TRUE(Munger.runTest("Good load float alignment 4", Align4,
                              array_lengthof(Align4)));
   EXPECT_TRUE(DumpMunger.runTestForAssembly("Good load float alignment 4",
                                             Align4, array_lengthof(Align4)));
   EXPECT_EQ("    %v0 = load float* %p0, align 4;\n",
             DumpMunger.getLinesWithSubstring("load"));
 
   const uint64_t Align29[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load float alignment 29", Align29,
                               array_lengthof(Align29)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 29",
                                              Align29, array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad load float alignment 30", Align30,
                               array_lengthof(Align30)));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad load float alignment 30",
                                              Align30, array_lengthof(Align30)));
   EXPECT_EQ(
       "    %v0 = load float* %p0, align 0;\n"
@@ skipping 27 matching lines @@
   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("Good store alignment"));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignZero(), Terminator,
   };
   EXPECT_FALSE(
       Munger.runTest("Bad store alignment 0", Align0, array_lengthof(Align0)));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 0", Align0,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(2), Terminator,
   };
   EXPECT_TRUE(
       Munger.runTest("Bad store alignment 4", Align4, array_lengthof(Align4)));
   EXPECT_TRUE(DumpMunger.runTestForAssembly("Good store alignment 4", Align4,
                                             array_lengthof(Align4)));
 
   // Show what happens when changing alignment to 8.
   const uint64_t Align8[] = {
-      ReplaceIndex, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(3), Terminator,
   };
   EXPECT_FALSE(
       Munger.runTest("Bad store alignment 8", Align8, array_lengthof(Align8)));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 8", Align8,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(29), Terminator,
   };
   EXPECT_FALSE(Munger.runTest("Bad store alignment 29", Align29,
                               array_lengthof(Align29)));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad store alignment 29", Align29,
                                              array_lengthof(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, NaClBitcodeMunger::Replace,
+      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("Bad store alignment 30", Align30,
                               array_lengthof(Align30)));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly("Bad Store alignment 30", Align30,
                                              array_lengthof(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