3 files changed, 233 insertions, 0 deletions
diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
new file mode 100644
index 00000000000..f58af220f2d
--- /dev/null
+++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
@@ -0,0 +1,167 @@
+//===- BitstreamReaderTest.cpp - Tests for BitstreamReader ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Bitstream/BitstreamReader.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitstream/BitstreamWriter.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(BitstreamReaderTest, AtEndOfStream) {
+  uint8_t Bytes[4] = {
+    0x00, 0x01, 0x02, 0x03
+  };
+  BitstreamCursor Cursor(Bytes);
+
+  EXPECT_FALSE(Cursor.AtEndOfStream());
+  Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(8);
+  EXPECT_TRUE((bool)MaybeRead);
+  EXPECT_FALSE(Cursor.AtEndOfStream());
+  MaybeRead = Cursor.Read(24);
+  EXPECT_TRUE((bool)MaybeRead);
+  EXPECT_TRUE(Cursor.AtEndOfStream());
+
+  EXPECT_FALSE(Cursor.JumpToBit(0));
+  EXPECT_FALSE(Cursor.AtEndOfStream());
+
+  EXPECT_FALSE(Cursor.JumpToBit(32));
+  EXPECT_TRUE(Cursor.AtEndOfStream());
+}
+
+TEST(BitstreamReaderTest, AtEndOfStreamJump) {
+  uint8_t Bytes[4] = {
+    0x00, 0x01, 0x02, 0x03
+  };
+  BitstreamCursor Cursor(Bytes);
+
+  EXPECT_FALSE(Cursor.JumpToBit(32));
+  EXPECT_TRUE(Cursor.AtEndOfStream());
+}
+
+TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
+  BitstreamCursor Cursor(ArrayRef<uint8_t>{});
+
+  EXPECT_TRUE(Cursor.AtEndOfStream());
+}
+
+TEST(BitstreamReaderTest, getCurrentByteNo) {
+  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03};
+  SimpleBitstreamCursor Cursor(Bytes);
+
+  for (unsigned I = 0, E = 32; I != E; ++I) {
+    EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
+    Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(1);
+    EXPECT_TRUE((bool)MaybeRead);
+  }
+  EXPECT_EQ(4u, Cursor.getCurrentByteNo());
+}
+
+TEST(BitstreamReaderTest, getPointerToByte) {
+  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+  SimpleBitstreamCursor Cursor(Bytes);
+
+  for (unsigned I = 0, E = 8; I != E; ++I) {
+    EXPECT_EQ(Bytes + I, Cursor.getPointerToByte(I, 1));
+  }
+}
+
+TEST(BitstreamReaderTest, getPointerToBit) {
+  uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+  SimpleBitstreamCursor Cursor(Bytes);
+
+  for (unsigned I = 0, E = 8; I != E; ++I) {
+    EXPECT_EQ(Bytes + I, Cursor.getPointerToBit(I * 8, 1));
+  }
+}
+
+TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) {
+  SmallVector<uint8_t, 1> BlobData;
+  for (unsigned I = 0, E = 1024; I != E; ++I)
+    BlobData.push_back(I);
+
+  // Try a bunch of different sizes.
+  const unsigned Magic = 0x12345678;
+  const unsigned BlockID = bitc::FIRST_APPLICATION_BLOCKID;
+  const unsigned RecordID = 1;
+  for (unsigned I = 0, BlobSize = 0, E = BlobData.size(); BlobSize < E;
+       BlobSize += ++I) {
+    StringRef BlobIn((const char *)BlobData.begin(), BlobSize);
+
+    // Write the bitcode.
+    SmallVector<char, 1> Buffer;
+    unsigned AbbrevID;
+    {
+      BitstreamWriter Stream(Buffer);
+      Stream.Emit(Magic, 32);
+      Stream.EnterSubblock(BlockID, 3);
+
+      auto Abbrev = std::make_shared<BitCodeAbbrev>();
+      Abbrev->Add(BitCodeAbbrevOp(RecordID));
+      Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
+      AbbrevID = Stream.EmitAbbrev(std::move(Abbrev));
+      unsigned Record[] = {RecordID};
+      Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn);
+
+      Stream.ExitBlock();
+    }
+
+    // Stream the buffer into the reader.
+    BitstreamCursor Stream(
+        ArrayRef<uint8_t>((const uint8_t *)Buffer.begin(), Buffer.size()));
+
+    // Header.  Included in test so that we can run llvm-bcanalyzer to debug
+    // when there are problems.
+    Expected<SimpleBitstreamCursor::word_t> MaybeRead = Stream.Read(32);
+    ASSERT_TRUE((bool)MaybeRead);
+    ASSERT_EQ(Magic, MaybeRead.get());
+
+    // Block.
+    Expected<BitstreamEntry> MaybeEntry =
+        Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
+    ASSERT_TRUE((bool)MaybeEntry);
+    BitstreamEntry Entry = MaybeEntry.get();
+    ASSERT_EQ(BitstreamEntry::SubBlock, Entry.Kind);
+    ASSERT_EQ(BlockID, Entry.ID);
+    ASSERT_FALSE(Stream.EnterSubBlock(BlockID));
+
+    // Abbreviation.
+    MaybeEntry = Stream.advance();
+    ASSERT_TRUE((bool)MaybeEntry);
+    Entry = MaybeEntry.get();
+    ASSERT_EQ(BitstreamEntry::Record, Entry.Kind);
+    ASSERT_EQ(AbbrevID, Entry.ID);
+
+    // Record.
+    StringRef BlobOut;
+    SmallVector<uint64_t, 1> Record;
+    Expected<unsigned> MaybeRecord =
+        Stream.readRecord(Entry.ID, Record, &BlobOut);
+    ASSERT_TRUE((bool)MaybeRecord);
+    ASSERT_EQ(RecordID, MaybeRecord.get());
+    EXPECT_TRUE(Record.empty());
+    EXPECT_EQ(BlobIn, BlobOut);
+  }
+}
+
+TEST(BitstreamReaderTest, shortRead) {
+  uint8_t Bytes[] = {8, 7, 6, 5, 4, 3, 2, 1};
+  for (unsigned I = 1; I != 8; ++I) {
+    SimpleBitstreamCursor Cursor(ArrayRef<uint8_t>(Bytes, I));
+    Expected<SimpleBitstreamCursor::word_t> MaybeRead = Cursor.Read(8);
+    ASSERT_TRUE((bool)MaybeRead);
+    EXPECT_EQ(8ull, MaybeRead.get());
+  }
+}
+
+static_assert(is_trivially_copyable<BitCodeAbbrevOp>::value,
+              "trivially copyable");
+
+} // end anonymous namespace
diff --git a/llvm/unittests/Bitstream/BitstreamWriterTest.cpp b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
new file mode 100644
index 00000000000..993c5aadee2
--- /dev/null
+++ b/llvm/unittests/Bitstream/BitstreamWriterTest.cpp
@@ -0,0 +1,58 @@
+//===- BitstreamWriterTest.cpp - Tests for BitstreamWriter ----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Bitstream/BitstreamWriter.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(BitstreamWriterTest, emitBlob) {
+  SmallString<64> Buffer;
+  BitstreamWriter W(Buffer);
+  W.emitBlob("str", /* ShouldEmitSize */ false);
+  EXPECT_EQ(StringRef("str\0", 4), Buffer);
+}
+
+TEST(BitstreamWriterTest, emitBlobWithSize) {
+  SmallString<64> Buffer;
+  {
+    BitstreamWriter W(Buffer);
+    W.emitBlob("str");
+  }
+  SmallString<64> Expected;
+  {
+    BitstreamWriter W(Expected);
+    W.EmitVBR(3, 6);
+    W.FlushToWord();
+    W.Emit('s', 8);
+    W.Emit('t', 8);
+    W.Emit('r', 8);
+    W.Emit(0, 8);
+  }
+  EXPECT_EQ(StringRef(Expected), Buffer);
+}
+
+TEST(BitstreamWriterTest, emitBlobEmpty) {
+  SmallString<64> Buffer;
+  BitstreamWriter W(Buffer);
+  W.emitBlob("", /* ShouldEmitSize */ false);
+  EXPECT_EQ(StringRef(""), Buffer);
+}
+
+TEST(BitstreamWriterTest, emitBlob4ByteAligned) {
+  SmallString<64> Buffer;
+  BitstreamWriter W(Buffer);
+  W.emitBlob("str0", /* ShouldEmitSize */ false);
+  EXPECT_EQ(StringRef("str0"), Buffer);
+}
+
+} // end namespace
diff --git a/llvm/unittests/Bitstream/CMakeLists.txt b/llvm/unittests/Bitstream/CMakeLists.txt
new file mode 100644
index 00000000000..a62003417d4
--- /dev/null
+++ b/llvm/unittests/Bitstream/CMakeLists.txt
@@ -0,0 +1,8 @@
+set(LLVM_LINK_COMPONENTS
+  BitstreamReader
+  )
+
+add_llvm_unittest(BitstreamTests
+  BitstreamReaderTest.cpp
+  BitstreamWriterTest.cpp
+  )