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

push bytecode decompressor out through APIs. Now the bytecode reader

Browse Source 
api's look like this:

ModuleProvider *getBytecodeModuleProvider(
  const std::string &Filename,  ///< Name of file to be read
  BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
  std::string* ErrMsg = 0,      ///< Optional error message holder
  BytecodeHandler* H = 0        ///< Optional handler for reader events
);

This is ugly, but allows a client to say:

  getBytecodeModuleProvider("foo", 0);

If they do this, there is no dependency on the compression libraries, saving
codesize.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34012 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2007-02-07 21:41:02 +00:00
parent 403e4a4725
commit f2e292ce58
25 changed files with 140 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/Bytecode/Archive/Archive.cpp
View File

@ -138,10 +138,10 @@ bool ArchiveMember::replaceWith(const sys::Path& newFile, std::string* ErrMsg) {
// Archive constructor - this is the only constructor that gets used for the
// Archive class. Everything else (default,copy) is deprecated. This just
// initializes and maps the file into memory, if requested.
Archive::Archive(const sys::Path& filename)
Archive::Archive(const sys::Path& filename, BCDecompressor_t *BCDC)
: archPath(filename), members(), mapfile(0), base(0), symTab(), strtab(),
symTabSize(0), firstFileOffset(0), modules(), foreignST(0)
{
symTabSize(0), firstFileOffset(0), modules(), foreignST(0),
Decompressor(BCDC) {
}
bool

17
lib/Bytecode/Archive/ArchiveReader.cpp
View File

@ -13,8 +13,8 @@
#include "ArchiveInternals.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Support/Compressor.h"
#include <memory>
using namespace llvm;
/// Read a variable-bit-rate encoded unsigned integer
@ -351,7 +351,9 @@ Archive::getAllModules(std::vector<Module*>& Modules, std::string* ErrMessage) {
std::string FullMemberName = archPath.toString() +
"(" + I->getPath().toString() + ")";
Module* M = ParseBytecodeBuffer((const unsigned char*)I->getData(),
I->getSize(), FullMemberName, ErrMessage);
I->getSize(), FullMemberName,
Compressor::decompressToNewBuffer,
ErrMessage);
if (!M)
return true;
@ -486,7 +488,7 @@ Archive::findModuleDefiningSymbol(const std::string& symbol,
mbr->getPath().toString() + ")";
ModuleProvider* mp = getBytecodeBufferModuleProvider(
(const unsigned char*) mbr->getData(), mbr->getSize(),
FullMemberName, ErrMsg, 0);
FullMemberName, Decompressor, ErrMsg, 0);
if (!mp)
return 0;
@ -500,8 +502,7 @@ Archive::findModuleDefiningSymbol(const std::string& symbol,
bool
Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
std::set<ModuleProvider*>& result,
std::string* error)
{
std::string* error) {
if (!mapfile || !base) {
if (error)
*error = "Empty archive invalid for finding modules defining symbols";
@ -533,8 +534,10 @@ Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
std::vector<std::string> symbols;
std::string FullMemberName = archPath.toString() + "(" +
mbr->getPath().toString() + ")";
ModuleProvider* MP = GetBytecodeSymbols((const unsigned char*)At,
mbr->getSize(), FullMemberName, symbols, error);
ModuleProvider* MP =
GetBytecodeSymbols((const unsigned char*)At, mbr->getSize(),
FullMemberName, symbols,
Compressor::decompressToNewBuffer, error);
if (MP) {
// Insert the module's symbols into the symbol table

6
lib/Bytecode/Archive/ArchiveWriter.cpp
View File

@ -225,8 +225,10 @@ Archive::writeMember(
std::string FullMemberName = archPath.toString() + "(" +
member.getPath().toString()
+ ")";
ModuleProvider* MP = GetBytecodeSymbols(
(const unsigned char*)data,fSize,FullMemberName, symbols, ErrMsg);
ModuleProvider* MP =
GetBytecodeSymbols((const unsigned char*)data,fSize,
FullMemberName, symbols,
Compressor::decompressToNewBuffer, ErrMsg);
// If the bytecode parsed successfully
if ( MP ) {

5
lib/Bytecode/Reader/Reader.cpp
View File

@ -1981,7 +1981,7 @@ void BytecodeReader::ParseModule() {
/// and \p Length parameters.
bool BytecodeReader::ParseBytecode(volatile BufPtr Buf, unsigned Length,
const std::string &ModuleID,
Decompressor_t *Decompressor,
BCDecompressor_t *Decompressor,
std::string* ErrMsg) {
/// We handle errors by
@ -2016,6 +2016,9 @@ bool BytecodeReader::ParseBytecode(volatile BufPtr Buf, unsigned Length,
// If this is a compressed file
if (Sig == ('l' | ('l' << 8) | ('v' << 16) | ('c' << 24))) {
if (!Decompressor) {
error("Compressed bytecode found, but not decompressor available");
}
// Invoke the decompression of the bytecode. Note that we have to skip the
// file's magic number which is not part of the compressed block. Hence,

7
lib/Bytecode/Reader/Reader.h
View File

@ -140,16 +140,15 @@ public:
/// @name Methods
/// @{
public:
typedef size_t Decompressor_t(const char *, size_t, char*&, std::string*);
typedef size_t BCDecompressor_t(const char *, size_t, char*&, std::string*);
/// @returns true if an error occurred
/// @brief Main interface to parsing a bytecode buffer.
bool ParseBytecode(
volatile BufPtr Buf, ///< Beginning of the bytecode buffer
unsigned Length, ///< Length of the bytecode buffer
const std::string &ModuleID, ///< An identifier for the module constructed.
Decompressor_t *Decompressor = 0, ///< Optional decompressor.
BCDecompressor_t *Decompressor = 0, ///< Optional decompressor.
std::string* ErrMsg = 0 ///< Optional place for error message
);

80
lib/Bytecode/Reader/ReaderWrappers.cpp
View File

@ -18,7 +18,6 @@
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Compressor.h"
#include "llvm/System/MappedFile.h"
#include "llvm/System/Program.h"
#include <cerrno>
@ -35,13 +34,15 @@ namespace {
class BytecodeFileReader : public BytecodeReader {
private:
std::string fileName;
BCDecompressor_t *Decompressor;
sys::MappedFile mapFile;
BytecodeFileReader(const BytecodeFileReader&); // Do not implement
void operator=(const BytecodeFileReader &BFR); // Do not implement
public:
BytecodeFileReader(const std::string &Filename, llvm::BytecodeHandler* H=0);
BytecodeFileReader(const std::string &Filename, BCDecompressor_t *BCDC,
llvm::BytecodeHandler* H=0);
bool read(std::string* ErrMsg);
void freeState() {
@ -52,8 +53,9 @@ namespace {
}
BytecodeFileReader::BytecodeFileReader(const std::string &Filename,
BCDecompressor_t *BCDC,
llvm::BytecodeHandler* H)
: BytecodeReader(H), fileName(Filename) {
: BytecodeReader(H), fileName(Filename), Decompressor(BCDC) {
}
bool BytecodeFileReader::read(std::string* ErrMsg) {
@ -65,7 +67,7 @@ bool BytecodeFileReader::read(std::string* ErrMsg) {
}
unsigned char* buffer = reinterpret_cast<unsigned char*>(mapFile.base());
return ParseBytecode(buffer, mapFile.size(), fileName,
Compressor::decompressToNewBuffer, ErrMsg);
Decompressor, ErrMsg);
}
//===----------------------------------------------------------------------===//
@ -81,6 +83,7 @@ namespace {
const unsigned char *Buf;
unsigned Length;
std::string ModuleID;
BCDecompressor_t *Decompressor;
bool MustDelete;
BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
@ -88,7 +91,7 @@ namespace {
public:
BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
const std::string &ModuleID,
const std::string &ModuleID, BCDecompressor_t *BCDC,
llvm::BytecodeHandler* Handler = 0);
~BytecodeBufferReader();
@ -100,9 +103,10 @@ namespace {
BytecodeBufferReader::BytecodeBufferReader(const unsigned char *buf,
unsigned len,
const std::string &modID,
BCDecompressor_t *BCDC,
llvm::BytecodeHandler *H)
: BytecodeReader(H), Buffer(0), Buf(buf), Length(len), ModuleID(modID)
, MustDelete(false) {
, Decompressor(BCDC), MustDelete(false) {
}
BytecodeBufferReader::~BytecodeBufferReader() {
@ -124,8 +128,7 @@ BytecodeBufferReader::read(std::string* ErrMsg) {
ParseBegin = Buffer = Buf;
MustDelete = false;
}
if (ParseBytecode(ParseBegin, Length, ModuleID,
Compressor::decompressToNewBuffer, ErrMsg)) {
if (ParseBytecode(ParseBegin, Length, ModuleID, Decompressor, ErrMsg)) {
if (MustDelete) delete [] Buffer;
return true;
}
@ -142,25 +145,24 @@ namespace {
class BytecodeStdinReader : public BytecodeReader {
private:
std::vector<unsigned char> FileData;
BCDecompressor_t *Decompressor;
unsigned char *FileBuf;
BytecodeStdinReader(const BytecodeStdinReader&); // Do not implement
void operator=(const BytecodeStdinReader &BFR); // Do not implement
public:
BytecodeStdinReader( llvm::BytecodeHandler* H = 0 );
BytecodeStdinReader(BCDecompressor_t *BCDC, llvm::BytecodeHandler* H = 0);
bool read(std::string* ErrMsg);
};
}
BytecodeStdinReader::BytecodeStdinReader( BytecodeHandler* H )
: BytecodeReader(H)
{
BytecodeStdinReader::BytecodeStdinReader(BCDecompressor_t *BCDC,
BytecodeHandler* H)
: BytecodeReader(H), Decompressor(BCDC) {
}
bool
BytecodeStdinReader::read(std::string* ErrMsg)
{
bool BytecodeStdinReader::read(std::string* ErrMsg) {
sys::Program::ChangeStdinToBinary();
char Buffer[4096*4];
@ -180,8 +182,7 @@ BytecodeStdinReader::read(std::string* ErrMsg)
}
FileBuf = &FileData[0];
if (ParseBytecode(FileBuf, FileData.size(), "<stdin>",
Compressor::decompressToNewBuffer, ErrMsg))
if (ParseBytecode(FileBuf, FileData.size(), "<stdin>", Decompressor, ErrMsg))
return true;
return false;
}
@ -196,10 +197,11 @@ ModuleProvider*
llvm::getBytecodeBufferModuleProvider(const unsigned char *Buffer,
unsigned Length,
const std::string &ModuleID,
BCDecompressor_t *BCDC,
std::string *ErrMsg,
BytecodeHandler *H) {
BytecodeBufferReader *rdr =
new BytecodeBufferReader(Buffer, Length, ModuleID, H);
new BytecodeBufferReader(Buffer, Length, ModuleID, BCDC, H);
if (rdr->read(ErrMsg))
return 0;
return rdr;
@ -209,9 +211,10 @@ llvm::getBytecodeBufferModuleProvider(const unsigned char *Buffer,
///
Module *llvm::ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
const std::string &ModuleID,
BCDecompressor_t *BCDC,
std::string *ErrMsg) {
ModuleProvider *MP =
getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, ErrMsg, 0);
getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
if (!MP) return 0;
Module *M = MP->releaseModule(ErrMsg);
delete MP;
@ -222,18 +225,19 @@ Module *llvm::ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
///
ModuleProvider *
llvm::getBytecodeModuleProvider(const std::string &Filename,
BCDecompressor_t *BCDC,
std::string* ErrMsg,
BytecodeHandler* H) {
// Read from a file
if (Filename != std::string("-")) {
BytecodeFileReader *rdr = new BytecodeFileReader(Filename, H);
BytecodeFileReader *rdr = new BytecodeFileReader(Filename, BCDC, H);
if (rdr->read(ErrMsg))
return 0;
return rdr;
}
// Read from stdin
BytecodeStdinReader *rdr = new BytecodeStdinReader(H);
BytecodeStdinReader *rdr = new BytecodeStdinReader(BCDC, H);
if (rdr->read(ErrMsg))
return 0;
return rdr;
@ -242,8 +246,9 @@ llvm::getBytecodeModuleProvider(const std::string &Filename,
/// ParseBytecodeFile - Parse the given bytecode file
///
Module *llvm::ParseBytecodeFile(const std::string &Filename,
BCDecompressor_t *BCDC,
std::string *ErrMsg) {
ModuleProvider* MP = getBytecodeModuleProvider(Filename, ErrMsg);
ModuleProvider* MP = getBytecodeModuleProvider(Filename, BCDC, ErrMsg);
if (!MP) return 0;
Module *M = MP->releaseModule(ErrMsg);
delete MP;
@ -254,30 +259,12 @@ Module *llvm::ParseBytecodeFile(const std::string &Filename,
Module* llvm::AnalyzeBytecodeFile(
const std::string &Filename, ///< File to analyze
BytecodeAnalysis& bca, ///< Statistical output
BCDecompressor_t *BCDC,
std::string *ErrMsg, ///< Error output
std::ostream* output ///< Dump output
) {
BytecodeHandler* AH = createBytecodeAnalyzerHandler(bca,output);
ModuleProvider* MP = getBytecodeModuleProvider(Filename, ErrMsg, AH);
if (!MP) return 0;
Module *M = MP->releaseModule(ErrMsg);
delete MP;
return M;
}
// AnalyzeBytecodeBuffer - analyze a buffer
Module* llvm::AnalyzeBytecodeBuffer(
const unsigned char* Buffer, ///< Pointer to start of bytecode buffer
unsigned Length, ///< Size of the bytecode buffer
const std::string& ModuleID, ///< Identifier for the module
BytecodeAnalysis& bca, ///< The results of the analysis
std::string* ErrMsg, ///< Errors, if any.
std::ostream* output ///< Dump output, if any
)
{
BytecodeHandler* hdlr = createBytecodeAnalyzerHandler(bca, output);
ModuleProvider* MP =
getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, ErrMsg, hdlr);
ModuleProvider* MP = getBytecodeModuleProvider(Filename, BCDC, ErrMsg, AH);
if (!MP) return 0;
Module *M = MP->releaseModule(ErrMsg);
delete MP;
@ -286,8 +273,9 @@ Module* llvm::AnalyzeBytecodeBuffer(
bool llvm::GetBytecodeDependentLibraries(const std::string &fname,
Module::LibraryListType& deplibs,
BCDecompressor_t *BCDC,
std::string* ErrMsg) {
ModuleProvider* MP = getBytecodeModuleProvider(fname, ErrMsg);
ModuleProvider* MP = getBytecodeModuleProvider(fname, BCDC, ErrMsg);
if (!MP) {
deplibs.clear();
return true;
@ -316,8 +304,9 @@ static void getSymbols(Module*M, std::vector<std::string>& symbols) {
// Get just the externally visible defined symbols from the bytecode
bool llvm::GetBytecodeSymbols(const sys::Path& fName,
std::vector<std::string>& symbols,
BCDecompressor_t *BCDC,
std::string* ErrMsg) {
ModuleProvider *MP = getBytecodeModuleProvider(fName.toString(), ErrMsg);
ModuleProvider *MP = getBytecodeModuleProvider(fName.toString(), BCDC,ErrMsg);
if (!MP)
return true;
@ -340,10 +329,11 @@ ModuleProvider*
llvm::GetBytecodeSymbols(const unsigned char*Buffer, unsigned Length,
const std::string& ModuleID,
std::vector<std::string>& symbols,
BCDecompressor_t *BCDC,
std::string* ErrMsg) {
// Get the module provider
ModuleProvider* MP =
getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, ErrMsg, 0);
getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
if (!MP)
return 0;