summaryrefslogtreecommitdiffstats
path: root/llvm/unittests/Bitcode
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/unittests/Bitcode')
-rw-r--r--llvm/unittests/Bitcode/BitReaderTest.cpp81
-rw-r--r--llvm/unittests/Bitcode/BitstreamReaderTest.cpp100
2 files changed, 11 insertions, 170 deletions
diff --git a/llvm/unittests/Bitcode/BitReaderTest.cpp b/llvm/unittests/Bitcode/BitReaderTest.cpp
index d0f33d12d5b..e4b90cc6855 100644
--- a/llvm/unittests/Bitcode/BitReaderTest.cpp
+++ b/llvm/unittests/Bitcode/BitReaderTest.cpp
@@ -18,11 +18,9 @@
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
-#include "llvm/Support/DataStream.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/StreamingMemoryObject.h"
#include "gtest/gtest.h"
using namespace llvm;
@@ -62,84 +60,6 @@ static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context,
return std::move(ModuleOrErr.get());
}
-class BufferDataStreamer : public DataStreamer {
- std::unique_ptr<MemoryBuffer> Buffer;
- unsigned Pos = 0;
- size_t GetBytes(unsigned char *Out, size_t Len) override {
- StringRef Buf = Buffer->getBuffer();
- size_t Left = Buf.size() - Pos;
- Len = std::min(Left, Len);
- memcpy(Out, Buffer->getBuffer().substr(Pos).data(), Len);
- Pos += Len;
- return Len;
- }
-
-public:
- BufferDataStreamer(std::unique_ptr<MemoryBuffer> Buffer)
- : Buffer(std::move(Buffer)) {}
-};
-
-static std::unique_ptr<Module>
-getStreamedModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem,
- const char *Assembly) {
- 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));
- ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
- getStreamedBitcodeModule("test", std::move(Streamer), Context);
- return std::move(ModuleOrErr.get());
-}
-
-// Checks if we correctly detect eof if we try to read N bits when there are not
-// enough bits left on the input stream to read N bits, and we are using a data
-// streamer. In particular, it checks if we properly set the object size when
-// the eof is reached under such conditions.
-TEST(BitReaderTest, TestForEofAfterReadFailureOnDataStreamer) {
- // Note: Because StreamingMemoryObject does a call to method GetBytes in it's
- // constructor, using internal constant kChunkSize, we must fill the input
- // with more characters than that amount.
- static size_t InputSize = StreamingMemoryObject::kChunkSize + 5;
- char *Text = new char[InputSize];
- std::memset(Text, 'a', InputSize);
- Text[InputSize - 1] = '\0';
- StringRef Input(Text);
-
- // Build bitsteam reader using data streamer.
- auto MemoryBuf = MemoryBuffer::getMemBuffer(Input);
- std::unique_ptr<DataStreamer> Streamer(
- new BufferDataStreamer(std::move(MemoryBuf)));
- auto OwnedBytes =
- llvm::make_unique<StreamingMemoryObject>(std::move(Streamer));
- auto Reader = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
- BitstreamCursor Cursor;
- Cursor.init(Reader.get());
-
- // Jump to two bytes before end of stream.
- Cursor.JumpToBit((InputSize - 4) * CHAR_BIT);
- // Try to read 4 bytes when only 2 are present, resulting in error value 0.
- const size_t ReadErrorValue = 0;
- EXPECT_EQ(ReadErrorValue, Cursor.Read(32));
- // Should be at eof now.
- EXPECT_TRUE(Cursor.AtEndOfStream());
-
- delete[] Text;
-}
-
-TEST(BitReaderTest, MateralizeForwardRefWithStream) {
- SmallString<1024> Mem;
-
- LLVMContext Context;
- std::unique_ptr<Module> M = getStreamedModuleFromAssembly(
- Context, Mem, "@table = constant i8* blockaddress(@func, %bb)\n"
- "define void @func() {\n"
- " unreachable\n"
- "bb:\n"
- " unreachable\n"
- "}\n");
- EXPECT_FALSE(M->getFunction("func")->empty());
-}
-
// Tests that lazy evaluation can parse functions out of order.
TEST(BitReaderTest, MaterializeFunctionsOutOfOrder) {
SmallString<1024> Mem;
@@ -216,6 +136,7 @@ TEST(BitReaderTest, MaterializeFunctionsForBlockAddr) { // PR11677
" unreachable\n"
"}\n");
EXPECT_FALSE(verifyModule(*M, &dbgs()));
+ EXPECT_FALSE(M->getFunction("func")->empty());
}
TEST(BitReaderTest, MaterializeFunctionsForBlockAddrInFunctionBefore) {
diff --git a/llvm/unittests/Bitcode/BitstreamReaderTest.cpp b/llvm/unittests/Bitcode/BitstreamReaderTest.cpp
index 2be774cc539..b5bd4a6fb5a 100644
--- a/llvm/unittests/Bitcode/BitstreamReaderTest.cpp
+++ b/llvm/unittests/Bitcode/BitstreamReaderTest.cpp
@@ -10,33 +10,17 @@
#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
};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
BitstreamCursor Cursor(Reader);
EXPECT_FALSE(Cursor.AtEndOfStream());
@@ -56,7 +40,7 @@ TEST(BitstreamReaderTest, AtEndOfStreamJump) {
uint8_t Bytes[4] = {
0x00, 0x01, 0x02, 0x03
};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
BitstreamCursor Cursor(Reader);
Cursor.JumpToBit(32);
@@ -64,8 +48,7 @@ TEST(BitstreamReaderTest, AtEndOfStreamJump) {
}
TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
- uint8_t Dummy = 0xFF;
- BitstreamReader Reader(&Dummy, &Dummy);
+ BitstreamReader Reader(ArrayRef<uint8_t>{});
BitstreamCursor Cursor(Reader);
EXPECT_TRUE(Cursor.AtEndOfStream());
@@ -73,10 +56,10 @@ TEST(BitstreamReaderTest, AtEndOfStreamEmpty) {
TEST(BitstreamReaderTest, getCurrentByteNo) {
uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
SimpleBitstreamCursor Cursor(Reader);
- for (unsigned I = 0, E = 33; I != E; ++I) {
+ for (unsigned I = 0, E = 32; I != E; ++I) {
EXPECT_EQ(I / 8, Cursor.getCurrentByteNo());
(void)Cursor.Read(1);
}
@@ -85,7 +68,7 @@ TEST(BitstreamReaderTest, getCurrentByteNo) {
TEST(BitstreamReaderTest, getPointerToByte) {
uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
SimpleBitstreamCursor Cursor(Reader);
for (unsigned I = 0, E = 8; I != E; ++I) {
@@ -95,7 +78,7 @@ TEST(BitstreamReaderTest, getPointerToByte) {
TEST(BitstreamReaderTest, getPointerToBit) {
uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
SimpleBitstreamCursor Cursor(Reader);
for (unsigned I = 0, E = 8; I != E; ++I) {
@@ -105,7 +88,7 @@ TEST(BitstreamReaderTest, getPointerToBit) {
TEST(BitstreamReaderTest, jumpToPointer) {
uint8_t Bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
- BitstreamReader Reader(std::begin(Bytes), std::end(Bytes));
+ BitstreamReader Reader(Bytes);
SimpleBitstreamCursor Cursor(Reader);
for (unsigned I : {0, 6, 2, 7}) {
@@ -114,68 +97,6 @@ TEST(BitstreamReaderTest, jumpToPointer) {
}
}
-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)
@@ -208,9 +129,8 @@ TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) {
}
// Stream the buffer into the reader.
- BitstreamReader R(llvm::make_unique<StreamingMemoryObject>(
- llvm::make_unique<BufferStreamer>(
- StringRef(Buffer.begin(), Buffer.size()))));
+ BitstreamReader R(
+ ArrayRef<uint8_t>((const uint8_t *)Buffer.begin(), Buffer.size()));
BitstreamCursor Stream(R);
// Header. Included in test so that we can run llvm-bcanalyzer to debug
OpenPOWER on IntegriCloud