Check for invalid abbreviation operators in munged bitcode.

unittests/Bitcode/NaClMungeWriteErrorTests.cpp

 //===- llvm/unittest/Bitcode/NaClMungeWriteErrorTests.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 20 matching lines @@
   0, naclbitc::BLK_CODE_EXIT, Terminator,
   3, naclbitc::MODULE_CODE_FUNCTION, 1, 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_RET, Terminator,
   0, naclbitc::BLK_CODE_EXIT, Terminator,
   0, naclbitc::BLK_CODE_EXIT, Terminator
 };
 
 // Expected output when bitcode records are dumped.
-const char* ExpectedDump =
+const char *ExpectedDump =
     "       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, 3>          |  types {  // BlockID = 17\n"
     "      32:0|    3: <1, 2>                |    count 2;\n"
     "      34:5|    3: <2>                   |    @t0 = void;\n"
     "      36:4|    3: <21, 0, 0>            |    @t1 = void ();\n"
     "      39:7|  0: <65534>                 |  }\n"
     "      44:0|  3: <8, 1, 0, 0, 0>         |  define external void @f0();\n"
     "      48:6|  1: <65535, 12, 2>          |  function void @f0() {  \n"
     "          |                             |                   // BlockID "
     "= 12\n"
     "      56:0|    3: <1, 1>                |    blocks 1;\n"
     "          |                             |  %b0:\n"
     "      58:4|    3: <10>                  |    ret void;\n"
     "      60:2|  0: <65534>                 |  }\n"
     "      64:0|0: <65534>                   |}\n"
     ;
 
+// Same as above, but just the records as generated by NaClWriteMunger.

[jvoung (off chromium), 2015/05/27 20:09:37]

I don't see a class named NaClWriteMunger.

[Karl, 2015/05/28 20:50:31]

I was trying to clarify what tool generated the output. The dump above is from
class NaClObjDumpMunger while the following is from NaClWriteMunger.

However, after thinking about it a bit more, I realized I could have just used
NaClObjDumpMunger as well. Fixing the code to do that.

Also realized that the check pattern use for abbreviations could be applied
elsewhere, removing code. So I'm also changing that.

+const char *ExpectedRecords =
+    "       1: [65535, 8, 2]\n"
+    "         1: [65535, 17, 3]\n"
+    "           3: [1, 2]\n"
+    "           3: [2]\n"
+    "           3: [21, 0, 0]\n"
+    "         0: [65534]\n"
+    "         3: [8, 1, 0, 0, 0]\n"
+    "         1: [65535, 12, 2]\n"
+    "           3: [1, 1]\n"
+    "           3: [10]\n"
+    "         0: [65534]\n"
+    "       0: [65534]\n";
+
+const char *UnableToContinue =
+      "Error: Unable to generate bitcode file due to write errors\n";
+
 // Edit to change void type with an illegal abbreviation index.
 const uint64_t VoidTypeIndex = 3; // Index for "@t0 = void".
 const uint64_t AbbrevIndex4VoidTypeEdit[] = {
   VoidTypeIndex, NaClMungedBitcode::Replace,
   4, naclbitc::TYPE_CODE_VOID, Terminator,
 };
 
 // Edit to add local abbreviation for "ret void", and then use on that
 // instruction.
 const uint64_t RetVoidIndex = 9; // return void;
@@ skipping 265 matching lines @@
     RetVoidIndex, NaClMungedBitcode::AddBefore,
         // Bad abbreviation! Intentionally leave out "literal" operand: 1
         2, naclbitc::BLK_CODE_DEFINE_ABBREV, 1, // 1,
         naclbitc::FUNC_CODE_INST_RET, Terminator,
         };
 
   // Show that the error is detected.
   NaClWriteMunger Munger(ARRAY_TERM(BitcodeRecords));
   EXPECT_FALSE(Munger.runTest(ARRAY(Edits)));
   EXPECT_EQ(
-      "Error (Block 12): Error: Bad abbreviation operand encoding 10:"
+      "Error (Block 12): Bad abbreviation operand encoding 10:"
       " 2: [65533, 1, 10]\n"
       "Error: Unable to generate bitcode file due to write errors\n",
       Munger.getTestResults());
 
   // Show that the writer can recover.
   Munger.setTryToRecoverOnWrite(true);
   EXPECT_TRUE(Munger.runTest(ARRAY(Edits)));
   EXPECT_EQ(
-      "Error (Block 12): Error: Bad abbreviation operand encoding 10: "
+      "Error (Block 12): Bad abbreviation operand encoding 10: "
       "2: [65533, 1, 10]\n"
       "       1: [65535, 8, 2]\n"
       "         1: [65535, 17, 3]\n"
       "           3: [1, 2]\n"
       "           3: [2]\n"
       "           3: [21, 0, 0]\n"
       "         0: [65534]\n"
       "         3: [8, 1, 0, 0, 0]\n"
       "         1: [65535, 12, 3]\n"  // Note: not followed by abbreviation def.
       "           3: [1, 1]\n"
@@ skipping 20 matching lines @@
     RetVoidIndex, NaClMungedBitcode::AddBefore,  // good abbreviation to ignore.
         2, naclbitc::BLK_CODE_DEFINE_ABBREV, 1, 1,
         naclbitc::FUNC_CODE_INST_RET, Terminator,
     RetVoidIndex, NaClMungedBitcode::Replace,  // reference to good abreviation.
         5, naclbitc::FUNC_CODE_INST_RET, Terminator
         };
 
   Munger.setTryToRecoverOnWrite(true);
   EXPECT_TRUE(Munger.runTest(ARRAY(Edits)));
   EXPECT_EQ(
-      "Error (Block 12): Error: Bad abbreviation operand encoding 9:"
+      "Error (Block 12): Bad abbreviation operand encoding 9:"
       " 2: [65533, 1, 9]\n"
       "Error (Block 12): Ignoring abbreviation: 2: [65533, 1, 1, 10]\n"
       "Error (Block 12): Uses illegal abbreviation index: 5: [10]\n"
       "       1: [65535, 8, 2]\n"
       "         1: [65535, 17, 3]\n"
       "           3: [1, 2]\n"
       "           3: [2]\n"
       "           3: [21, 0, 0]\n"
       "         0: [65534]\n"
       "         3: [8, 1, 0, 0, 0]\n"
@@ skipping 145 matching lines @@
       "           3: [1, 1]\n"
       "           3: [10]\n"
       "         0: [65534]\n"
       "       0: [65534]\n"
       "       1: [65535, 4294967295, 3]\n"
       "         3: [1, 4]\n"
       "       0: [65534]\n",
       Munger.getTestResults());
 }
 
+// Runs write munging tests on BitcodeRecords, inserting bad
+// abbreviation definitions via Edit.  ErrorMessage is the expected

[jvoung (off chromium), 2015/05/27 20:09:37]

via Edit -> via Edits ?

[Karl, 2015/05/28 20:50:32]

Done.

+// error message to be generated by the write munger. Assumes the the

[jvoung (off chromium), 2015/05/27 20:09:37]

the the -> that the

[Karl, 2015/05/28 20:50:31]

Done.

+// error recovery is to delete the bad abbreviation definitions.

[jvoung (off chromium), 2015/05/27 20:09:37]

error recover -> error recover method

or something like that?

[Karl, 2015/05/28 20:50:31]

No longer applicable. Comments were rewritten.

+void CheckWriteBadAbbrevMunging(const uint64_t *Edits, size_t EditsSize,
+                                const char *ErrorMessage) {
+  NaClWriteMunger Munger(ARRAY_TERM(BitcodeRecords));
+  EXPECT_FALSE(Munger.runTest(Edits, EditsSize));
+  std::string BadResults(ErrorMessage);
+  BadResults.append(UnableToContinue);
+  EXPECT_EQ(BadResults, Munger.getTestResults());
+
+  Munger.setTryToRecoverOnWrite(true);
+  EXPECT_TRUE(Munger.runTest(Edits, EditsSize));
+  std::string GoodResults(ErrorMessage);
+  GoodResults.append(ExpectedRecords);
+  EXPECT_EQ(GoodResults, Munger.getTestResults());
+}
+
+// Show that inserting an abbreviation with a bad fixed width is dealt with.
+TEST(NaClMungeWriteErrorTests, InvalidFixedAbbreviationSize) {
+  // Insert bad abbreviation Fixed(36) into type block.

[jvoung (off chromium), 2015/05/27 20:09:37]

how about static_assert(36 > naclbitc::MaxAbbrevWidth, "...");

To show why 36 is chosen.

[Karl, 2015/05/28 20:50:31]

Done.

+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 1,
+      0, NaClBitCodeAbbrevOp::Fixed, 36, Terminator

[jvoung (off chromium), 2015/05/27 20:09:38]

can line up the 0, ... with the other array elems from the earlier rows

[Karl, 2015/05/28 20:50:32]

Done.

+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Invalid abbreviation Fixed(36) in: 2: [65533, 1, 0,"
+      " 1, 36]\n");
+}
+
+// Show that inserting an abbreviation with a bad vbr width is dealt with.
+TEST(NaClMungeWriteErrorTests, InvalidVbrAbbreviationSize) {
+  // Insert bad abbreviation Vbr(36) into type block.
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 1,
+    0, NaClBitCodeAbbrevOp::VBR, 36,
+    Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Invalid abbreviation VBR(36) in: 2: [65533, 1, 0,"
+      " 2, 36]\n");
+}
+
+// Show that the array operator can't appear last.
+TEST(NaClMungeWriteErrorTests, InvalidArrayAbbreviationLast) {
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 1,
+    0, NaClBitCodeAbbrevOp::Array, Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Malformed array abbreviation found: 2: [65533, 1,"
+      " 0, 3]\n");
+}
+
+// Show that the array operator can't appear before the second to last
+// operand.
+TEST(NaClMungeWriteErrorTests, InvalidArrayAbbreviationTooEarly) {
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 3,
+    0, NaClBitCodeAbbrevOp::Array,  // array
+    1, 15,                          // lit(15)
+    1, 10,                          // lit(10)
+    Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Array abbreviation must be second to last: 2: [65533,"
+      " 3, 0, 3, 1, 15, 1, 10]\n");
+}
+
+// Show that the array operator can't appear as last two operators.
+TEST(NaClMungeWriteErrorTests, InvalidArrayAbbreviationLastTwo) {
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 2,
+    0, NaClBitCodeAbbrevOp::Array,  // array
+    0, NaClBitCodeAbbrevOp::Array,  // array
+    Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Malformed array abbreviation found: 2: [65533, 2,"
+      " 0, 3, 0, 3]\n");
+}
+
+// Show that the code checks if specifies too few operands for an

[jvoung (off chromium), 2015/05/27 20:09:37]

nit: "Show that the code checks if specifies too few operands" sounds a bit odd.

[Karl, 2015/05/28 20:50:31]

Rewritten.

+// abbreviation, based on the record size.
+TEST(NaClMungeWriteErrorTests, SpecifiesTooFewOperands) {
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 1,
+    1, 10,                          // lit(10)
+    1, 15,                          // lit(15)
+    Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Error: Too many values for number of operands (1):"
+      " 2: [65533, 1, 1, 10, 1, 15]\n");
+}
+
+// Show that the code checks if specifies too many operands for an
+// abbreviation, based on the record size.
+TEST(NaClMungeWriteErrorTests, SpecifiesTooManyOperands) {
+  // Insert bad abbreviation Vbr(36) into type block.
+  const uint64_t Edit[] = {
+    VoidTypeIndex, NaClMungedBitcode::AddBefore,
+    naclbitc::DEFINE_ABBREV, naclbitc::BLK_CODE_DEFINE_ABBREV, 3,
+    1, 10,                          // lit(10)
+    1, 15,                          // lit(15)
+    Terminator
+  };
+  CheckWriteBadAbbrevMunging(
+      ARRAY(Edit),
+      "Error (Block 17): Malformed abbreviation found. Expects 3 operands"
+      " but found 2: 2: [65533, 3, 1, 10, 1, 15]\n");
+}
+
 } // end of namespace naclmungetest