Fix the NaCl bitstream reader to report fatal errors.

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 37 matching lines @@
     // 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 text of base input.
   NaClObjDumpMunger DumpMunger(BitcodeRecords,
                                array_lengthof(BitcodeRecords), Terminator);
-  EXPECT_FALSE(DumpMunger.runTestForAssembly("Nonexistant call arg"));
+  //EXPECT_FALSE(DumpMunger.runTestForAssembly("Nonexistant call arg"));

[jvoung (off chromium), 2015/02/20 00:12:42]

remove commented out version?

[Karl, 2015/02/20 21:41:17]

Done.

+  EXPECT_FALSE(DumpMunger.runTest("Nonexistant call arg"));
   EXPECT_EQ(
-      "module {  // BlockID = 8\n"
-      "  types {  // BlockID = 17\n"
-      "    count 3;\n"
-      "    @t0 = i32;\n"
-      "    @t1 = void;\n"
-      "    @t2 = void (i32, i32);\n"
-      "  }\n"
-      "  declare external void @f0(i32, i32);\n"
-      "  define external void @f1(i32, i32);\n"
-      "  function void @f1(i32 %p0, i32 %p1) {  // BlockID = 12\n"
-      "    blocks 1;\n"
-      "  %b0:\n"
-      "    call void @f0(i32 %p0, i32 @f0);\n"
+      "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
+      "88, 69)\n"
+      "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
+      "          | 0>                          |\n"
+      "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
+      "      24:0|  1: <65535, 17, 2>          |  types {  // BlockID = 17\n"
+      "      32:0|    3: <1, 3>                |    count 3;\n"
+      "      34:4|    3: <7, 32>               |    @t0 = i32;\n"
+      "      37:6|    3: <2>                   |    @t1 = void;\n"
+      "      39:4|    3: <21, 0, 1, 0, 0>      |    @t2 = void (i32, i32);\n"
+      "      44:2|  0: <65534>                 |  }\n"
+      "      48:0|  3: <8, 2, 0, 1, 0>         |  declare external void @f0(i32"
+      ", i32);\n"
+      "      52:6|  3: <8, 2, 0, 0, 0>         |  define external void @f1(i32,"
+      " i32);\n"
+      "      57:4|  1: <65535, 12, 2>          |  function void @f1(i32 %p0, "
+      "i32 %p1) {\n"
+      "          |                             |                    // BlockID "
+      "= 12\n"
+      "      64:0|    3: <1, 1>                |    blocks 1;\n"
+      "          |                             |  %b0:\n"
+      "      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"
-      "    ret void;\n"
-      "  }\n"
-      "}\n",
+      "      72:6|    3: <10>                  |    ret void;\n"
+      "      74:4|  0: <65534>                 |  }\n"
+      "      76:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
 
   NaClParseBitcodeMunger Munger(BitcodeRecords,
                                 array_lengthof(BitcodeRecords), Terminator);
   EXPECT_FALSE(Munger.runTest("Nonexistant call arg", true));
   EXPECT_EQ(
-      "Error: (56:6) Invalid call argument: Index 1\n"
+      "Error: (72:6) Invalid call argument: Index 1\n"
       "Error: Invalid value in record\n",
       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,
     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, 0, 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(BitcodeRecords,
                                array_lengthof(BitcodeRecords), Terminator);
-  EXPECT_TRUE(DumpMunger.runTestForAssembly("BadAllocaAlignment"));
+  EXPECT_TRUE(DumpMunger.runTest("BadAllocaAlignment"));
   EXPECT_EQ(
-      "module {  // BlockID = 8\n"
-      "  types {  // BlockID = 17\n"
-      "    count 4;\n"
-      "    @t0 = i32;\n"
-      "    @t1 = void;\n"
-      "    @t2 = void (i32);\n"
-      "    @t3 = i8;\n"
-      "  }\n"
-      "  define external void @f0(i32);\n"
-      "  function void @f0(i32 %p0) {  // BlockID = 12\n"
-      "    blocks 1;\n"
-      "  %b0:\n"
-      "    %v0 = alloca i8, i32 %p0, align 1;\n"
-      "    ret void;\n"
-      "  }\n"
-      "}\n",
+      "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
+      "88, 69)\n"
+      "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
+      "          | 0>                          |\n"
+      "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
+      "      24:0|  1: <65535, 17, 2>          |  types {  // BlockID = 17\n"
+      "      32:0|    3: <1, 4>                |    count 4;\n"
+      "      34:4|    3: <7, 32>               |    @t0 = i32;\n"
+      "      37:6|    3: <2>                   |    @t1 = void;\n"
+      "      39:4|    3: <21, 0, 1, 0>         |    @t2 = void (i32);\n"
+      "      43:4|    3: <7, 8>                |    @t3 = i8;\n"
+      "      46:0|  0: <65534>                 |  }\n"
+      "      48:0|  3: <8, 2, 0, 0, 0>         |  define external void @f0(i32"
+      ");\n"
+      "      52:6|  1: <65535, 12, 2>          |  function void @f0(i32 %p0) {"
+      "  \n"
+      "          |                             |                   // BlockID "
+      "= 12\n"
+      "      60:0|    3: <1, 1>                |    blocks 1;\n"
+      "          |                             |  %b0:\n"
+      "      62:4|    3: <19, 1, 1>            |    %v0 = alloca i8, i32 %p0, "
+      "align 1;\n"
+      "      65:6|    3: <10>                  |    ret void;\n"
+      "      67:4|  0: <65534>                 |  }\n"
+      "      68:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
   NaClParseBitcodeMunger Munger(BitcodeRecords,
                                 array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("BadAllocaAlignment", true));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
     ReplaceIndex, NaClBitcodeMunger::Replace,
     3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignZero(), Terminator,
   };
   EXPECT_TRUE(Munger.runTest(
       "BadAllocaAlignment-0", Align0, array_lengthof(Align0), true));
   EXPECT_TRUE(DumpMunger.runTestForAssembly(
       "BadAllocaAlignment-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,
     3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(30), Terminator,
   };
   EXPECT_FALSE(Munger.runTest(
       "BadAllocaAlignment-30", Align30, array_lengthof(Align30), true));
   EXPECT_EQ(
-      "Error: (49:6) Alignment can't be greater than 2**29. Found: 2**30\n"
+      "Error: (65:6) Alignment can't be greater than 2**29. Found: 2**30\n"
       "Error: Invalid value in record\n",
       Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(
       "BadAllocaAlignment-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"));
@@ skipping 31 matching lines @@
     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(BitcodeRecords,
                                array_lengthof(BitcodeRecords), Terminator);
-  EXPECT_TRUE(DumpMunger.runTestForAssembly("BadLoadAlignment-1"));
+  EXPECT_TRUE(DumpMunger.runTest("BadLoadAlignment-1"));
   EXPECT_EQ(
-      "module {  // BlockID = 8\n"
-      "  types {  // BlockID = 17\n"
-      "    count 2;\n"
-      "    @t0 = i32;\n"
-      "    @t1 = i32 (i32);\n"
-      "  }\n"
-      "  define external i32 @f0(i32);\n"
-      "  function i32 @f0(i32 %p0) {  // BlockID = 12\n"
-      "    blocks 1;\n"
-      "  %b0:\n"
-      "    %v0 = load i32* %p0, align 1;\n"
-      "    ret i32 %v0;\n"
-      "  }\n"
-      "}\n",
+      "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
+      "88, 69)\n"
+      "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
+      "          | 0>                          |\n"
+      "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
+      "      24:0|  1: <65535, 17, 2>          |  types {  // BlockID = 17\n"
+      "      32:0|    3: <1, 2>                |    count 2;\n"
+      "      34:4|    3: <7, 32>               |    @t0 = i32;\n"
+      "      37:6|    3: <21, 0, 0, 0>         |    @t1 = i32 (i32);\n"
+      "      41:6|  0: <65534>                 |  }\n"
+      "      44:0|  3: <8, 1, 0, 0, 0>         |  define external i32 @f0(i32"
+      ");\n"
+      "      48:6|  1: <65535, 12, 2>          |  function i32 @f0(i32 %p0) {"
+      "  \n"
+      "          |                             |                   // BlockID "
+      "= 12\n"
+      "      56:0|    3: <1, 1>                |    blocks 1;\n"
+      "          |                             |  %b0:\n"
+      "      58:4|    3: <20, 1, 1, 0>         |    %v0 = load i32* %p0, "
+      "align 1;\n"
+      "      62:4|    3: <10, 1>               |    ret i32 %v0;\n"
+      "      65:0|  0: <65534>                 |  }\n"
+      "      68:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
   NaClParseBitcodeMunger Munger(BitcodeRecords,
                                 array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("BadLoadAlignment", true));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
     ReplaceIndex, NaClBitcodeMunger::Replace,
     3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
   };
@@ skipping 39 matching lines @@
       DumpMunger.getLinesWithSubstring("load"));
 
   // Show what happens when changing alignment to 2**30.
   const uint64_t Align30[] = {
     ReplaceIndex, NaClBitcodeMunger::Replace,
     3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
   };
   EXPECT_FALSE(Munger.runTest(
       "BadLoadAlignment-30", Align30, array_lengthof(Align30), true));
   EXPECT_EQ(
-      "Error: (46:4) Alignment can't be greater than 2**29. Found: 2**30\n"
+      "Error: (62:4) Alignment can't be greater than 2**29. Found: 2**30\n"
       "Error: Invalid value in record\n",
       Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(
       "BadLoadAlignment-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",
       DumpMunger.getLinesWithSubstring("load"));
 }
 
@@ skipping 14 matching lines @@
     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.runTestForAssembly("BadStoreAlignment"));
+  EXPECT_TRUE(DumpMunger.runTest("BadStoreAlignment"));
   EXPECT_EQ(
-      "module {  // BlockID = 8\n"
-      "  types {  // BlockID = 17\n"
-      "    count 3;\n"
-      "    @t0 = float;\n"
-      "    @t1 = i32;\n"
-      "    @t2 = float (i32, float);\n"
-      "  }\n"
-      "  define external float @f0(i32, float);\n"
-      "  function float @f0(i32 %p0, float %p1) {  // BlockID = 12\n"
-      "    blocks 1;\n"
-      "  %b0:\n"
-      "    store float %p1, float* %p0, align 1;\n"
-      "    ret float %p1;\n"
-      "  }\n"
-      "}\n",
+      "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
+      "88, 69)\n"
+      "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
+      "          | 0>                          |\n"
+      "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
+      "      24:0|  1: <65535, 17, 2>          |  types {  // BlockID = 17\n"
+      "      32:0|    3: <1, 3>                |    count 3;\n"
+      "      34:4|    3: <3>                   |    @t0 = float;\n"
+      "      36:2|    3: <7, 32>               |    @t1 = i32;\n"
+      "      39:4|    3: <21, 0, 0, 1, 0>      |    @t2 = float (i32, float);\n"
+      "      44:2|  0: <65534>                 |  }\n"
+      "      48:0|  3: <8, 2, 0, 0, 0>         |  define external \n"
+      "          |                             |      float @f0(i32, float);\n"
+      "      52:6|  1: <65535, 12, 2>          |  function \n"
+      "          |                             |      float @f0(i32 %p0, float "
+      "%p1) {  \n"
+      "          |                             |                   // BlockID "
+      "= 12\n"
+      "      60:0|    3: <1, 1>                |    blocks 1;\n"
+      "          |                             |  %b0:\n"
+      "      62:4|    3: <24, 2, 1, 1>         |    store float %p1, float* "
+      "%p0, \n"
+      "          |                             |        align 1;\n"
+      "      66:4|    3: <10, 1>               |    ret float %p1;\n"
+      "      69:0|  0: <65534>                 |  }\n"
+      "      72:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
   NaClParseBitcodeMunger Munger(BitcodeRecords,
                                 array_lengthof(BitcodeRecords), Terminator);
   EXPECT_TRUE(Munger.runTest("BadStoreAlignment", true));
 
   // Show what happens when changing alignment to 0.
   const uint64_t Align0[] = {
     ReplaceIndex, NaClBitcodeMunger::Replace,
     3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignZero(), Terminator,
   };
@@ skipping 49 matching lines @@
       DumpMunger.getLinesWithSubstring("store"));
 
   // Show what happens when changing alignment to 2**30.
   const uint64_t Align30[] = {
     ReplaceIndex, NaClBitcodeMunger::Replace,
     3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(30), Terminator,
   };
   EXPECT_FALSE(Munger.runTest(
       "BadStoreAlignment-30", Align30, array_lengthof(Align30), true));
   EXPECT_EQ(
-      "Error: (50:4) Alignment can't be greater than 2**29. Found: 2**30\n"
+      "Error: (66:4) Alignment can't be greater than 2**29. Found: 2**30\n"
       "Error: Invalid value in record\n",
       Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(
       "BadStoreAlignment-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 anonamous namespace.