#define LLVM_BYTECODE_ANALYZER_H
#include "llvm/Bytecode/Format.h"
+#include "llvm/Bytecode/Reader.h"
#include <string>
#include <map>
-#include <ostream>
+#include <iosfwd>
namespace llvm {
Module* AnalyzeBytecodeFile(
const std::string& Filename, ///< The name of the bytecode file to read
BytecodeAnalysis& Results, ///< The results of the analysis
+ BCDecompressor_t *BCDC = 0, ///< Optional decompressor to use.
std::string* ErrorStr = 0, ///< Errors, if any.
std::ostream* output = 0 ///< Stream for dump output, if wanted
);
-/// This function is an alternate entry point into the bytecode analysis
-/// library. It allows you to provide an arbitrary memory buffer which is
-/// assumed to contain a complete bytecode file. The \p Buffer is analyzed and
-/// the \p Results are filled in.
-/// @brief Analyze contents of a bytecode buffer.
-Module* AnalyzeBytecodeBuffer(
- const unsigned char* Buffer, ///< Pointer to start of bytecode buffer
- unsigned BufferSize, ///< Size of the bytecode buffer
- const std::string& ModuleID, ///< Identifier for the module
- BytecodeAnalysis& Results, ///< The results of the analysis
- std::string* ErrorStr = 0, ///< Errors, if any.
- std::ostream* output = 0 ///< Stream for dump output, if wanted
- );
/// This function prints the contents of rhe BytecodeAnalysis structure in
/// a human legible form.
#include "llvm/ADT/ilist"
#include "llvm/System/Path.h"
#include "llvm/System/MappedFile.h"
+#include "llvm/Support/Compressor.h"
#include <map>
#include <set>
#include <fstream>
class Archive; // Declared below
class ArchiveMemberHeader; // Internal implementation class
+typedef size_t BCDecompressor_t(const char *, size_t, char*&, std::string*);
+
+
/// This class is the main class manipulated by users of the Archive class. It
/// holds information about one member of the Archive. It is also the element
/// stored by the Archive's ilist, the Archive's main abstraction. Because of
/// applications and the linkers. Consequently, the implementation of the class
/// is optimized for reading.
class Archive {
-
+
/// @name Types
/// @{
public:
protected:
/// @brief Construct an Archive for \p filename and optionally map it
/// into memory.
- Archive(const sys::Path& filename);
+ Archive(const sys::Path& filename, BCDecompressor_t *BCDC =
+ Compressor::decompressToNewBuffer);
/// @param error Set to address of a std::string to get error messages
/// @returns false on error
unsigned firstFileOffset; ///< Offset to first normal file.
ModuleMap modules; ///< The modules loaded via symbol lookup.
ArchiveMember* foreignST; ///< This holds the foreign symbol table.
-
+ BCDecompressor_t *Decompressor; ///< Optional decompressor
/// @}
/// @name Hidden
/// @{
#ifndef LLVM_BYTECODE_READER_H
#define LLVM_BYTECODE_READER_H
-#include "llvm/System/Path.h"
#include "llvm/ModuleProvider.h"
#include "llvm/Module.h"
-#include <string>
+#include "llvm/Support/Compressor.h"
+#include "llvm/System/Path.h"
namespace llvm {
// Forward declare the handler class
class BytecodeHandler;
+typedef size_t BCDecompressor_t(const char *, size_t, char*&, std::string*);
+
/// This function returns a ModuleProvider that can be used to do lazy
/// function-at-a-time loading from a bytecode file.
/// @returns NULL on error
/// @brief Get a ModuleProvide for a bytecode file.
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
);
const unsigned char *Buffer, ///< Start of buffer to parse
unsigned BufferSize, ///< Size of the buffer
const std::string &ModuleID, ///< Name to give the module
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string* ErrMsg = 0, ///< Optional place to return an error message
BytecodeHandler* H = 0 ///< Optional handler for reader events
);
/// @brief Parse the given bytecode file
Module* ParseBytecodeFile(
const std::string &Filename, ///< Name of file to parse
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string *ErrMsg = 0 ///< Optional place to return an error message
);
const unsigned char *Buffer, ///< Start of buffer to parse
unsigned BufferSize, ///< Size of the buffer
const std::string &ModuleID="", ///< Name to give the module
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string *ErrMsg = 0 ///< Optional place to return an error message
);
bool GetBytecodeDependentLibraries(
const std::string &fileName, ///< File name to read bytecode from
Module::LibraryListType& deplibs, ///< List of dependent libraries extracted
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string* ErrMsg = 0 ///< Optional error message holder
);
bool GetBytecodeSymbols(
const sys::Path& fileName, ///< Filename to read bytecode from
std::vector<std::string>& syms, ///< Vector to return symbols in
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string* ErrMsg = 0 ///< Optional error message holder
);
unsigned Length, ///< The length of \p Buffer
const std::string& ModuleID, ///< An identifier for the module
std::vector<std::string>& symbols, ///< The symbols defined in the module
+ BCDecompressor_t *BCDC = Compressor::decompressToNewBuffer,
std::string* ErrMsg = 0 ///< Optional error message holder
);
// 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
#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
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;
mbr->getPath().toString() + ")";
ModuleProvider* mp = getBytecodeBufferModuleProvider(
(const unsigned char*) mbr->getData(), mbr->getSize(),
- FullMemberName, ErrMsg, 0);
+ FullMemberName, Decompressor, ErrMsg, 0);
if (!mp)
return 0;
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";
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
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 ) {
// 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
#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
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;
mbr->getPath().toString() + ")";
ModuleProvider* mp = getBytecodeBufferModuleProvider(
(const unsigned char*) mbr->getData(), mbr->getSize(),
- FullMemberName, ErrMsg, 0);
+ FullMemberName, Decompressor, ErrMsg, 0);
if (!mp)
return 0;
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";
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
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 ) {
/// 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
// 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,
/// @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
);
#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>
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() {
}
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) {
}
unsigned char* buffer = reinterpret_cast<unsigned char*>(mapFile.base());
return ParseBytecode(buffer, mapFile.size(), fileName,
- Compressor::decompressToNewBuffer, ErrMsg);
+ Decompressor, ErrMsg);
}
//===----------------------------------------------------------------------===//
const unsigned char *Buf;
unsigned Length;
std::string ModuleID;
+ BCDecompressor_t *Decompressor;
bool MustDelete;
BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
public:
BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
- const std::string &ModuleID,
+ const std::string &ModuleID, BCDecompressor_t *BCDC,
llvm::BytecodeHandler* Handler = 0);
~BytecodeBufferReader();
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() {
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;
}
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];
}
FileBuf = &FileData[0];
- if (ParseBytecode(FileBuf, FileData.size(), "<stdin>",
- Compressor::decompressToNewBuffer, ErrMsg))
+ if (ParseBytecode(FileBuf, FileData.size(), "<stdin>", Decompressor, ErrMsg))
return true;
return false;
}
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;
///
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;
///
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;
/// 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;
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;
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;
// 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;
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;
#include "llvm/Bytecode/Reader.h"
#include "llvm/Config/config.h"
#include "llvm/Support/Streams.h"
+#include "llvm/Support/Compressor.h"
using namespace llvm;
Linker::Linker(const std::string& progname, const std::string& modname, unsigned flags)
std::auto_ptr<Module>
Linker::LoadObject(const sys::Path &FN) {
std::string ParseErrorMessage;
- Module *Result = ParseBytecodeFile(FN.toString(), &ParseErrorMessage);
+ Module *Result = ParseBytecodeFile(FN.toString(),
+ Compressor::decompressToNewBuffer,
+ &ParseErrorMessage);
if (Result)
return std::auto_ptr<Module>(Result);
Error = "Bytecode file '" + FN.toString() + "' could not be loaded";
#include "llvm/Assembly/Parser.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/FileUtilities.h"
#include <iostream>
#include <memory>
///
Module *llvm::ParseInputFile(const std::string &InputFilename) {
ParseError Err;
- Module *Result = ParseBytecodeFile(InputFilename);
+ Module *Result = ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer);
if (!Result && !(Result = ParseAssemblyFile(InputFilename,&Err))) {
std::cerr << "bugpoint: " << Err.getMessage() << "\n";
Result = 0;
#include "llvm/PassManager.h"
#include "llvm/Pass.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/PluginLoader.h"
#include "llvm/Support/FileUtilities.h"
sys::PrintStackTraceOnErrorSignal();
// Load the module to be compiled...
- std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
+ std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer));
if (M.get() == 0) {
std::cerr << argv[0] << ": bytecode didn't read correctly.\n";
return 1;
#include "llvm/ExecutionEngine/Interpreter.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/PluginLoader.h"
#include "llvm/System/Process.h"
// Load the bytecode...
std::string ErrorMsg;
ModuleProvider *MP = 0;
- MP = getBytecodeModuleProvider(InputFile, &ErrorMsg);
+ MP = getBytecodeModuleProvider(InputFile,
+ Compressor::decompressToNewBuffer,
+ &ErrorMsg);
if (!MP) {
std::cerr << "Error loading program '" << InputFile << "': "
<< ErrorMsg << "\n";
#include "llvm/Analysis/Verifier.h"
#include "llvm/Bytecode/Analyzer.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/System/Signals.h"
#include <fstream>
bca.progressiveVerify = Verify;
/// Analyze the bytecode file
- Module* M = AnalyzeBytecodeFile(InputFilename, bca, &ErrorMessage, (Dump?Out:0));
+ Module* M = AnalyzeBytecodeFile(InputFilename, bca,
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage, (Dump?Out:0));
// All that bcanalyzer does is write the gathered statistics to the output
PrintBytecodeAnalysis(bca,*Out);
#include "llvm/PassManager.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Assembly/PrintModulePass.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Streams.h"
std::ostream *Out = &std::cout; // Default to printing to stdout.
std::string ErrorMessage;
- std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename, &ErrorMessage));
+ std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage));
if (M.get() == 0) {
cerr << argv[0] << ": ";
if (ErrorMessage.size())
#include "llvm/Transforms/IPO.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compressor.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
cl::ParseCommandLineOptions(argc, argv, " llvm extractor\n");
sys::PrintStackTraceOnErrorSignal();
- std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
+ std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer));
if (M.get() == 0) {
cerr << argv[0] << ": bytecode didn't read correctly.\n";
return 1;
std::string ErrorMessage;
if (Filename.exists()) {
if (Verbose) cerr << "Loading '" << Filename.c_str() << "'\n";
- Module* Result = ParseBytecodeFile(Filename.toString(), &ErrorMessage);
+ Module* Result = ParseBytecodeFile(Filename.toString(),
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage);
if (Result) return std::auto_ptr<Module>(Result); // Load successful!
if (Verbose) {
}
// Note: Currently we do not support reading an archive from stdin.
if (Filename == "-" || aPath.isBytecodeFile()) {
- Module *Result = ParseBytecodeFile(Filename, &ErrorMessage);
+ Module *Result = ParseBytecodeFile(Filename,
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage);
if (Result) {
DumpSymbolNamesFromModule (Result);
} else {
// Read in the bytecode file...
std::string ErrorMessage;
- Module *M = ParseBytecodeFile(BytecodeFile, &ErrorMessage);
+ Module *M = ParseBytecodeFile(BytecodeFile,
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage);
if (M == 0) {
std::cerr << argv[0] << ": " << BytecodeFile << ": "
<< ErrorMessage << "\n";
int exitCode = 0;
std::ostream *Out = 0;
std::string ErrorMessage;
- std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename, &ErrorMessage));
+ std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer,
+ &ErrorMessage));
if (M.get() == 0) {
std::cerr << argv[0] << ": ";
if (ErrorMessage.size())
if (fullpath.isBytecodeFile()) {
// Process the dependent libraries recursively
Module::LibraryListType modlibs;
- if (GetBytecodeDependentLibraries(fullpath.toString(),modlibs,&err)) {
+ if (GetBytecodeDependentLibraries(fullpath.toString(),modlibs,
+ Compressor::decompressToNewBuffer,
+ &err)) {
// Traverse the dependent libraries list
Module::lib_iterator LI = modlibs.begin();
Module::lib_iterator LE = modlibs.end();
std::string ErrorMessage;
// Load the input module...
- std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename, &ErrorMessage));
+ std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename,
+ Compressor::decompressToNewBuffer, &ErrorMessage));
if (M.get() == 0) {
cerr << argv[0] << ": ";
if (ErrorMessage.size())
projects / oota-llvm.git / commitdiff