Switch the bitcode reader interface to take a MemoryBuffer instead of knowing
anything about disk I/O itself. This greatly simplifies its interface -
eliminating the need for the ReaderWrappers.cpp file.
This adds a new option to llvm-dis (-bitcode) which instructs it to read
the input file as bitcode. Until/unless the bytecode reader is taught to
read from MemoryBuffer, there is no way to handle stdin reading without it.
I don't plan to switch the bytecode reader over, I'd rather delete it :),
so the option will stay around temporarily.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36554 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 2a6de41..6157a5d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -11,6 +11,7 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/Bitcode/ReaderWriter.h"
#include "BitcodeReader.h"
#include "llvm/Bitcode/BitstreamReader.h"
#include "llvm/Constants.h"
@@ -18,8 +19,14 @@
#include "llvm/Module.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
using namespace llvm;
+BitcodeReader::~BitcodeReader() {
+ delete Buffer;
+}
+
+
/// ConvertToString - Convert a string from a record into an std::string, return
/// true on failure.
template<typename StrTy>
@@ -852,14 +859,14 @@
}
-bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
- const std::string &ModuleID) {
+bool BitcodeReader::ParseBitcode() {
TheModule = 0;
- if (Length & 3)
+ if (Buffer->getBufferSize() & 3)
return Error("Bitcode stream should be a multiple of 4 bytes in length");
- BitstreamReader Stream(Buf, Buf+Length);
+ unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
+ BitstreamReader Stream(BufPtr, BufPtr+Buffer->getBufferSize());
// Sniff for the signature.
if (Stream.Read(8) != 'B' ||
@@ -882,7 +889,7 @@
// We only know the MODULE subblock ID.
if (BlockID == bitc::MODULE_BLOCK_ID) {
- if (ParseModule(Stream, ModuleID))
+ if (ParseModule(Stream, Buffer->getBufferIdentifier()))
return true;
} else if (Stream.SkipBlock()) {
return Error("Malformed block record");
@@ -891,3 +898,41 @@
return false;
}
+
+//===----------------------------------------------------------------------===//
+// External interface
+//===----------------------------------------------------------------------===//
+
+/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
+///
+ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
+ std::string *ErrMsg) {
+ BitcodeReader *R = new BitcodeReader(Buffer);
+ if (R->ParseBitcode()) {
+ if (ErrMsg)
+ *ErrMsg = R->getErrorString();
+
+ // Don't let the BitcodeReader dtor delete 'Buffer'.
+ R->releaseMemoryBuffer();
+ delete R;
+ return 0;
+ }
+ return R;
+}
+
+/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
+/// If an error occurs, return null and fill in *ErrMsg if non-null.
+Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
+ BitcodeReader *R;
+ R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
+ if (!R) return 0;
+
+ // Read the whole module, get a pointer to it, tell ModuleProvider not to
+ // delete it when its dtor is run.
+ Module *M = R->releaseModule(ErrMsg);
+
+ // Don't let the BitcodeReader dtor delete 'Buffer'.
+ R->releaseMemoryBuffer();
+ delete R;
+ return M;
+}
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 8e21134..0935c06 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -22,6 +22,7 @@
namespace llvm {
class BitstreamReader;
+ class MemoryBuffer;
class BitcodeReaderValueList : public User {
std::vector<Use> Uses;
@@ -57,6 +58,7 @@
class BitcodeReader : public ModuleProvider {
+ MemoryBuffer *Buffer;
const char *ErrorString;
std::vector<PATypeHolder> TypeList;
@@ -64,10 +66,16 @@
std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
public:
- BitcodeReader() : ErrorString(0) {}
- virtual ~BitcodeReader() {}
+ BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {}
+ ~BitcodeReader();
- virtual void FreeState() {}
+
+ /// releaseMemoryBuffer - This causes the reader to completely forget about
+ /// the memory buffer it contains, which prevents the buffer from being
+ /// destroyed when it is deleted.
+ void releaseMemoryBuffer() {
+ Buffer = 0;
+ }
virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0) {
// FIXME: TODO
@@ -89,8 +97,7 @@
/// @brief Main interface to parsing a bitcode buffer.
/// @returns true if an error occurred.
- bool ParseBitcode(unsigned char *Buf, unsigned Length,
- const std::string &ModuleID);
+ bool ParseBitcode();
private:
const Type *getTypeByID(unsigned ID, bool isTypeTable = false);
diff --git a/lib/Bitcode/Reader/ReaderWrappers.cpp b/lib/Bitcode/Reader/ReaderWrappers.cpp
deleted file mode 100644
index 8bf81a2..0000000
--- a/lib/Bitcode/Reader/ReaderWrappers.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===- ReaderWrappers.cpp - Parse bitcode from file or buffer -------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements loading and parsing a bitcode file and parsing a
-// module from a memory buffer.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bitcode/ReaderWriter.h"
-#include "BitcodeReader.h"
-#include "llvm/System/MappedFile.h"
-using namespace llvm;
-
-//===----------------------------------------------------------------------===//
-// BitcodeFileReader - Read from an mmap'able file descriptor.
-
-namespace {
- /// BitcodeFileReader - parses bitcode from a file.
- ///
- class BitcodeFileReader : public BitcodeReader {
- private:
- std::string Filename;
- sys::MappedFile File;
-
- BitcodeFileReader(const BitcodeFileReader&); // DO NOT IMPLEMENT
- void operator=(const BitcodeFileReader&); // DO NOT IMPLEMENT
- public:
- BitcodeFileReader(const std::string &FN) : Filename(FN) {}
- bool Read(std::string *ErrMsg);
-
- void FreeState() {
- BitcodeReader::FreeState();
- File.close();
- }
- };
-}
-
-bool BitcodeFileReader::Read(std::string *ErrMsg) {
- if (File.open(sys::Path(Filename), sys::MappedFile::READ_ACCESS, ErrMsg))
- return true;
- if (!File.map(ErrMsg)) {
- File.close();
- return true;
- }
- unsigned char *Buffer = reinterpret_cast<unsigned char*>(File.base());
- if (!ParseBitcode(Buffer, File.size(), Filename))
- return false;
- assert(getErrorString() && "Didn't set an error string?");
- if (ErrMsg) *ErrMsg = getErrorString();
- return true;
-}
-
-
-
-//===----------------------------------------------------------------------===//
-// External interface
-//===----------------------------------------------------------------------===//
-
-/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
-///
-ModuleProvider *llvm::getBitcodeModuleProvider(const std::string &Filename,
- std::string *ErrMsg) {
- if (Filename != std::string("-")) {
- BitcodeFileReader *R = new BitcodeFileReader(Filename);
- if (R->Read(ErrMsg)) {
- delete R;
- return 0;
- }
- return R;
- }
-
- assert(0 && "FIXME: stdin reading unimp!");
-#if 0
- // Read from stdin
- BytecodeStdinReader *R = new BytecodeStdinReader();
- if (R->Read(ErrMsg)) {
- delete R;
- return 0;
- }
- return R;
-#endif
-}
-
-/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
-/// If an error occurs, return null and fill in *ErrMsg if non-null.
-Module *llvm::ParseBitcodeFile(const std::string &Filename,std::string *ErrMsg){
- ModuleProvider *MP = getBitcodeModuleProvider(Filename, ErrMsg);
- if (!MP) return 0;
- Module *M = MP->releaseModule(ErrMsg);
- delete MP;
- return M;
-}