summaryrefslogtreecommitdiff
path: root/unittests/Bitcode
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/Bitcode')
-rw-r--r--unittests/Bitcode/BitReaderTest.cpp10
-rw-r--r--unittests/Bitcode/BitstreamReaderTest.cpp185
-rw-r--r--unittests/Bitcode/BitstreamWriterTest.cpp59
-rw-r--r--unittests/Bitcode/CMakeLists.txt1
-rw-r--r--unittests/Bitcode/Makefile15
5 files changed, 250 insertions, 20 deletions
diff --git a/unittests/Bitcode/BitReaderTest.cpp b/unittests/Bitcode/BitReaderTest.cpp
index 420aca2443bb..d0f33d12d5bc 100644
--- a/unittests/Bitcode/BitReaderTest.cpp
+++ b/unittests/Bitcode/BitReaderTest.cpp
@@ -29,10 +29,10 @@ using namespace llvm;
namespace {
-std::unique_ptr<Module> parseAssembly(const char *Assembly) {
+std::unique_ptr<Module> parseAssembly(LLVMContext &Context,
+ const char *Assembly) {
SMDiagnostic Error;
- std::unique_ptr<Module> M =
- parseAssemblyString(Assembly, Error, getGlobalContext());
+ std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context);
std::string ErrMsg;
raw_string_ostream OS(ErrMsg);
@@ -54,7 +54,7 @@ static void writeModuleToBuffer(std::unique_ptr<Module> Mod,
static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context,
SmallString<1024> &Mem,
const char *Assembly) {
- writeModuleToBuffer(parseAssembly(Assembly), Mem);
+ writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
std::unique_ptr<MemoryBuffer> Buffer =
MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
@@ -82,7 +82,7 @@ public:
static std::unique_ptr<Module>
getStreamedModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem,
const char *Assembly) {
- writeModuleToBuffer(parseAssembly(Assembly), Mem);
+ writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
std::unique_ptr<MemoryBuffer> Buffer =
MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
auto Streamer = llvm::make_unique<BufferDataStreamer>(std::move(Buffer));
diff --git a/unittests/Bitcode/BitstreamReaderTest.cpp b/unittests/Bitcode/BitstreamReaderTest.cpp
index b11d7fde7749..2be774cc5394 100644
--- a/unittests/Bitcode/BitstreamReaderTest.cpp
+++ b/unittests/Bitcode/BitstreamReaderTest.cpp
@@ -7,13 +7,31 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/ADT/STLExtras.h"
#include "llvm/Bitcode/BitstreamReader.h"
+#include "llvm/Bitcode/BitstreamWriter.h"
+#include "llvm/Support/StreamingMemoryObject.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
+class BufferStreamer : public DataStreamer {
+ StringRef Buffer;
+
+public:
+ BufferStreamer(StringRef Buffer) : Buffer(Buffer) {}
+ size_t GetBytes(unsigned char *OutBuffer, size_t Length) override {
+ if (Length >= Buffer.size())
+ Length = Buffer.size();
+
+ std::copy(Buffer.begin(), Buffer.begin() + Length, OutBuffer);
+ Buffer = Buffer.drop_front(Length);
+ return Length;
+ }
+};
+
TEST(BitstreamReaderTest, AtEndOfStream) {
uint8_t Bytes[4] = {
0x00, 0x01, 0x02, 0x03
@@ -53,4 +71,171 @@ TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
EXPECT_TRUE(Cursor.AtEndOfStream());
}
+TEST(BitstreamReaderTest, getCurrentByteNo) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ for (unsigned I = 0, E = 33; I != E; ++I) {
+ EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
+ (void)Cursor.Read(1);
+ }
+ EXPECT_EQ(4u, Cursor.getCurrentByteNo());
+}
+
+TEST(BitstreamReaderTest, getPointerToByte) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ 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};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ for (unsigned I = 0, E = 8; I != E; ++I) {
+ EXPECT_EQ(Bytes + I, Cursor.getPointerToBit(I * 8, 1));
+ }
+}
+
+TEST(BitstreamReaderTest, jumpToPointer) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ for (unsigned I : {0, 6, 2, 7}) {
+ Cursor.jumpToPointer(Bytes + I);
+ EXPECT_EQ(I, Cursor.getCurrentByteNo());
+ }
+}
+
+TEST(BitstreamReaderTest, setArtificialByteLimit) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ Cursor.setArtificialByteLimit(8);
+ EXPECT_EQ(8u, Cursor.getSizeIfKnown());
+ while (!Cursor.AtEndOfStream())
+ (void)Cursor.Read(1);
+
+ EXPECT_EQ(8u, Cursor.getCurrentByteNo());
+}
+
+TEST(BitstreamReaderTest, setArtificialByteLimitNotWordBoundary) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ Cursor.setArtificialByteLimit(5);
+ EXPECT_EQ(8u, Cursor.getSizeIfKnown());
+ while (!Cursor.AtEndOfStream())
+ (void)Cursor.Read(1);
+
+ EXPECT_EQ(8u, Cursor.getCurrentByteNo());
+}
+
+TEST(BitstreamReaderTest, setArtificialByteLimitPastTheEnd) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ // The size of the memory object isn't known yet. Set it too high and
+ // confirm that we don't read too far.
+ Cursor.setArtificialByteLimit(24);
+ EXPECT_EQ(24u, Cursor.getSizeIfKnown());
+ while (!Cursor.AtEndOfStream())
+ (void)Cursor.Read(1);
+
+ EXPECT_EQ(12u, Cursor.getCurrentByteNo());
+ EXPECT_EQ(12u, Cursor.getSizeIfKnown());
+}
+
+TEST(BitstreamReaderTest, setArtificialByteLimitPastTheEndKnown) {
+ uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b};
+ BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ SimpleBitstreamCursor Cursor(Reader);
+
+ // Save the size of the memory object in the cursor.
+ while (!Cursor.AtEndOfStream())
+ (void)Cursor.Read(1);
+ EXPECT_EQ(12u, Cursor.getCurrentByteNo());
+ EXPECT_EQ(12u, Cursor.getSizeIfKnown());
+
+ Cursor.setArtificialByteLimit(20);
+ EXPECT_TRUE(Cursor.AtEndOfStream());
+ EXPECT_EQ(12u, Cursor.getSizeIfKnown());
+}
+
+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);
+
+ BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
+ Abbrev->Add(BitCodeAbbrevOp(RecordID));
+ Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
+ AbbrevID = Stream.EmitAbbrev(Abbrev);
+ unsigned Record[] = {RecordID};
+ Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn);
+
+ Stream.ExitBlock();
+ }
+
+ // Stream the buffer into the reader.
+ BitstreamReader R(llvm::make_unique<StreamingMemoryObject>(
+ llvm::make_unique<BufferStreamer>(
+ StringRef(Buffer.begin(), Buffer.size()))));
+ BitstreamCursor Stream(R);
+
+ // Header. Included in test so that we can run llvm-bcanalyzer to debug
+ // when there are problems.
+ ASSERT_EQ(Magic, Stream.Read(32));
+
+ // Block.
+ BitstreamEntry Entry =
+ Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
+ ASSERT_EQ(BitstreamEntry::SubBlock, Entry.Kind);
+ ASSERT_EQ(BlockID, Entry.ID);
+ ASSERT_FALSE(Stream.EnterSubBlock(BlockID));
+
+ // Abbreviation.
+ Entry = Stream.advance();
+ ASSERT_EQ(BitstreamEntry::Record, Entry.Kind);
+ ASSERT_EQ(AbbrevID, Entry.ID);
+
+ // Record.
+ StringRef BlobOut;
+ SmallVector<uint64_t, 1> Record;
+ ASSERT_EQ(RecordID, Stream.readRecord(Entry.ID, Record, &BlobOut));
+ EXPECT_TRUE(Record.empty());
+ EXPECT_EQ(BlobIn, BlobOut);
+ }
+}
+
} // end anonymous namespace
diff --git a/unittests/Bitcode/BitstreamWriterTest.cpp b/unittests/Bitcode/BitstreamWriterTest.cpp
new file mode 100644
index 000000000000..f17cc157cde9
--- /dev/null
+++ b/unittests/Bitcode/BitstreamWriterTest.cpp
@@ -0,0 +1,59 @@
+//===- 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/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Bitcode/BitstreamWriter.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/unittests/Bitcode/CMakeLists.txt b/unittests/Bitcode/CMakeLists.txt
index 09cbcdc7284d..4d06f8008d38 100644
--- a/unittests/Bitcode/CMakeLists.txt
+++ b/unittests/Bitcode/CMakeLists.txt
@@ -9,4 +9,5 @@ set(LLVM_LINK_COMPONENTS
add_llvm_unittest(BitcodeTests
BitReaderTest.cpp
BitstreamReaderTest.cpp
+ BitstreamWriterTest.cpp
)
diff --git a/unittests/Bitcode/Makefile b/unittests/Bitcode/Makefile
deleted file mode 100644
index 33b09b914b56..000000000000
--- a/unittests/Bitcode/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-##===- unittests/Bitcode/Makefile --------------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-LEVEL = ../..
-TESTNAME = Bitcode
-LINK_COMPONENTS := AsmParser BitReader BitWriter Core Support
-
-include $(LEVEL)/Makefile.config
-include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-07 03:30:34 +0000