6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-12 13:38:21 +00:00
Code Issues Projects Releases Wiki Activity

Switch the bitcode reader interface to take a MemoryBuffer instead of knowing

Browse Source 
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
This commit is contained in:
Chris Lattner
2007-04-29 07:54:31 +00:00
parent 333ffd4abf
commit c453f76e2b
5 changed files with 96 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -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::ParseModule(BitstreamReader &Stream,
}
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 @@ bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
// 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 @@ bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
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;
}