6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-14 14:24:05 +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;
}

17
lib/Bitcode/Reader/BitcodeReader.h
View File

@ -22,6 +22,7 @@
namespace llvm {
class BitstreamReader;
class MemoryBuffer;
class BitcodeReaderValueList : public User {
std::vector<Use> Uses;
@ -57,6 +58,7 @@ public:
class BitcodeReader : public ModuleProvider {
MemoryBuffer *Buffer;
const char *ErrorString;
std::vector<PATypeHolder> TypeList;
@ -64,10 +66,16 @@ class BitcodeReader : public ModuleProvider {
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 @@ public:
/// @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);

98
lib/Bitcode/Reader/ReaderWrappers.cpp
View File

@ -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;
}