Install notion of diagnostic handler into PNaCl bitcode readers.

unittests/Bitcode/NaClParseInstsTest.cpp

 //===- llvm/unittest/Bitcode/NaClParseInstsTest.cpp ----------------------===//
 //     Tests parser for PNaCl bitcode instructions.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 65 matching lines @@
       "      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"
       "      72:6|    3: <10>                  |    ret void;\n"
       "      74:4|  0: <65534>                 |  }\n"
       "      76:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
 
   NaClParseBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
   EXPECT_FALSE(Munger.runTest(true));
-  EXPECT_EQ(
-      "Error(72:6): Invalid call argument: Index 1\n"
-      "Error: Invalid value in record\n",
-      Munger.getTestResults());
+  EXPECT_EQ("Invalid call argument: Index 1\n"
+            "Corrupted bitcode\n",
+            stripErrorPrefix(Munger.getTestResults()));
 }
 
 /// Test how we recognize alignments in alloca instructions.
 TEST(NaClParseInstsTests, BadAllocaAlignment) {
   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,
@@ skipping 54 matching lines @@
   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), true));
-  EXPECT_EQ(
-      "Error(65:6): Alignment can't be greater than 2**29. Found: 2**30\n"
-      "Error: Invalid value in record\n",
-      Munger.getTestResults());
+  EXPECT_EQ("Alignment can't be greater than 2**29. Found: 2**30\n"
+            "Corrupted bitcode\n",
+            stripErrorPrefix(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[] = {
@@ skipping 100 matching lines @@
       "    %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), true));
-  EXPECT_EQ(
-      "Error(62:4): Alignment can't be greater than 2**29. Found: 2**30\n"
-      "Error: Invalid value in record\n",
-      Munger.getTestResults());
+  EXPECT_EQ("Alignment can't be greater than 2**29. Found: 2**30\n"
+            "Corrupted bitcode\n",
+            stripErrorPrefix(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 store instructions.
 TEST(NaClParseInstsTests, BadStoreAlignment) {
   const uint64_t BitcodeRecords[] = {
@@ skipping 96 matching lines @@
       "    store float %p1, float* %p0, align 536870912;\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**30.
   const uint64_t Align30[] = {
     ReplaceIndex, NaClMungedBitcode::Replace,
     3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(30), Terminator,
   };
   EXPECT_FALSE(Munger.runTest(ARRAY(Align30), true));
-  EXPECT_EQ(
-      "Error(66:4): Alignment can't be greater than 2**29. Found: 2**30\n"
-      "Error: Invalid value in record\n",
-      Munger.getTestResults());
+  EXPECT_EQ("Alignment can't be greater than 2**29. Found: 2**30\n"
+            "Corrupted bitcode\n",
+            stripErrorPrefix(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 namespace naclmungetest