Bitcode: Fix assert when writing arrays as blobs.

[bartell]

Summary

When BitstreamWriter::EmitRecordWithAbbrevImpl is used to write a blob, but the blob data is provided in the Vals array argument instead of the Blob argument, it triggers an assertion failure. This happens because RecordIdx isn't updated correctly, so it looks like there are still unemitted values left in the Vals array. We fix this by updating RecordIdx to reflect the fact that everything in Vals has been emitted.

(LLVM currently always provides blob data in the Blob argument, so it can't trigger this bug as-is.)

[pcc]

I didn't even know that you could pass a blob that way. What do you think about dropping support for this feature since it is evidently unused (except possibly by you? But you can switch to EmitRecordWithBlob, right?)

include/llvm/Bitcode/BitstreamWriter.h

for (; i != e; ++i) {
                  "Blob data and record entries specified for blob operand!");
 
           assert(Blob.data() == BlobData && "BlobData got moved");
           assert(Blob.size() == BlobLen && "BlobLen got changed");
           emitBlob(Blob);
           BlobData = nullptr;
         } else {
           emitBlob(Vals.slice(RecordIdx));
+          RecordIdx = Vals.size();
         }
       } else {  // Single scalar field.
         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
         EmitAbbreviatedField(Op, Vals[RecordIdx]);
         ++RecordIdx;
       }
     }
     assert(RecordIdx == Vals.size() && "Not all record operands emitted!");

unittests/Bitcode/BitstreamWriterTest.cpp

 //===- BitstreamWriterTest.cpp - Tests for BitstreamWriter ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Bitcode/BitstreamWriter.h"
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Bitcode/BitCodes.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 TEST(BitstreamWriterTest, emitBlob) {
   SmallString<64> Buffer;

 
 TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
   SmallString<64> Buffer;
   BitstreamWriter W(Buffer);
   W.emitBlob("str0", /* ShouldEmitSize */ false);
   EXPECT_EQ(StringRef("str0"), Buffer);
 }
 
+TEST(BitstreamWriterTest, emitBlobFromArray) {
+  auto Abbrev = std::make_shared<BitCodeAbbrev>();
+  Abbrev->Add(BitCodeAbbrevOp(0));
+  Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
+  SmallString<64> Buffer;
+  {
+    SmallVector<uint64_t, 1> Vals = {0, 0x12, 0x34};
+    BitstreamWriter W(Buffer);
+    W.EnterSubblock(0, 3);
+    unsigned AbbrevID = W.EmitAbbrev(Abbrev);
+    W.EmitRecordWithAbbrev(AbbrevID, Vals);
+    W.ExitBlock();
+  }
+  SmallString<64> Expected;
+  {
+    SmallVector<uint64_t, 1> Vals = {0};
+    BitstreamWriter W(Expected);
+    W.EnterSubblock(0, 3);
+    unsigned AbbrevID = W.EmitAbbrev(Abbrev);
+    W.EmitRecordWithBlob(AbbrevID, Vals, "\x12\x34");
+    W.ExitBlock();
+  }
+  EXPECT_EQ(StringRef(Expected), Buffer);
+}
+
 } // end namespace