mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-20 11:29:24 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14093 91177308-0d34-0410-b5e6-96231b3b80d8
228 lines
7.5 KiB
C++
228 lines
7.5 KiB
C++
//===- AnalyzerWrappers.cpp - Analyze bytecode from file or buffer -------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by Reid Spencer and is distributed under the
|
|
// University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements loading and analysis of a bytecode file and analyzing a
|
|
// bytecode buffer.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Bytecode/Analyzer.h"
|
|
#include "AnalyzerInternals.h"
|
|
#include "Support/FileUtilities.h"
|
|
#include "Support/StringExtras.h"
|
|
#include "Config/unistd.h"
|
|
#include <cerrno>
|
|
|
|
using namespace llvm;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// BytecodeFileAnalyzer - Analyze from an mmap'able file descriptor.
|
|
//
|
|
|
|
namespace {
|
|
/// BytecodeFileAnalyzer - parses a bytecode file from a file
|
|
class BytecodeFileAnalyzer : public BytecodeAnalyzer {
|
|
private:
|
|
unsigned char *Buffer;
|
|
unsigned Length;
|
|
|
|
BytecodeFileAnalyzer(const BytecodeFileAnalyzer&); // Do not implement
|
|
void operator=(const BytecodeFileAnalyzer &BFR); // Do not implement
|
|
|
|
public:
|
|
BytecodeFileAnalyzer(const std::string &Filename, BytecodeAnalysis& bca);
|
|
~BytecodeFileAnalyzer();
|
|
};
|
|
}
|
|
|
|
static std::string ErrnoMessage (int savedErrNum, std::string descr) {
|
|
return ::strerror(savedErrNum) + std::string(", while trying to ") + descr;
|
|
}
|
|
|
|
BytecodeFileAnalyzer::BytecodeFileAnalyzer(const std::string &Filename,
|
|
BytecodeAnalysis& bca) {
|
|
Buffer = (unsigned char*)ReadFileIntoAddressSpace(Filename, Length);
|
|
if (Buffer == 0)
|
|
throw "Error reading file '" + Filename + "'.";
|
|
|
|
try {
|
|
// Parse the bytecode we mmapped in
|
|
if ( bca.dumpBytecode )
|
|
DumpBytecode(Buffer, Length, bca, Filename);
|
|
AnalyzeBytecode(Buffer, Length, bca, Filename);
|
|
} catch (...) {
|
|
UnmapFileFromAddressSpace(Buffer, Length);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
BytecodeFileAnalyzer::~BytecodeFileAnalyzer() {
|
|
// Unmmap the bytecode...
|
|
UnmapFileFromAddressSpace(Buffer, Length);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// BytecodeBufferAnalyzer - Read from a memory buffer
|
|
//
|
|
|
|
namespace {
|
|
/// BytecodeBufferAnalyzer - parses a bytecode file from a buffer
|
|
///
|
|
class BytecodeBufferAnalyzer : public BytecodeAnalyzer {
|
|
private:
|
|
const unsigned char *Buffer;
|
|
bool MustDelete;
|
|
|
|
BytecodeBufferAnalyzer(const BytecodeBufferAnalyzer&); // Do not implement
|
|
void operator=(const BytecodeBufferAnalyzer &BFR); // Do not implement
|
|
|
|
public:
|
|
BytecodeBufferAnalyzer(const unsigned char *Buf, unsigned Length,
|
|
BytecodeAnalysis& bca, const std::string &ModuleID);
|
|
~BytecodeBufferAnalyzer();
|
|
|
|
};
|
|
}
|
|
|
|
BytecodeBufferAnalyzer::BytecodeBufferAnalyzer(const unsigned char *Buf,
|
|
unsigned Length,
|
|
BytecodeAnalysis& bca,
|
|
const std::string &ModuleID) {
|
|
// If not aligned, allocate a new buffer to hold the bytecode...
|
|
const unsigned char *ParseBegin = 0;
|
|
if ((intptr_t)Buf & 3) {
|
|
Buffer = new unsigned char[Length+4];
|
|
unsigned Offset = 4 - ((intptr_t)Buffer & 3); // Make sure it's aligned
|
|
ParseBegin = Buffer + Offset;
|
|
memcpy((unsigned char*)ParseBegin, Buf, Length); // Copy it over
|
|
MustDelete = true;
|
|
} else {
|
|
// If we don't need to copy it over, just use the caller's copy
|
|
ParseBegin = Buffer = Buf;
|
|
MustDelete = false;
|
|
}
|
|
try {
|
|
if ( bca.dumpBytecode )
|
|
DumpBytecode(ParseBegin, Length, bca, ModuleID);
|
|
AnalyzeBytecode(ParseBegin, Length, bca, ModuleID);
|
|
} catch (...) {
|
|
if (MustDelete) delete [] Buffer;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
BytecodeBufferAnalyzer::~BytecodeBufferAnalyzer() {
|
|
if (MustDelete) delete [] Buffer;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// BytecodeStdinAnalyzer - Read bytecode from Standard Input
|
|
//
|
|
|
|
namespace {
|
|
/// BytecodeStdinAnalyzer - parses a bytecode file from stdin
|
|
///
|
|
class BytecodeStdinAnalyzer : public BytecodeAnalyzer {
|
|
private:
|
|
std::vector<unsigned char> FileData;
|
|
unsigned char *FileBuf;
|
|
|
|
BytecodeStdinAnalyzer(const BytecodeStdinAnalyzer&); // Do not implement
|
|
void operator=(const BytecodeStdinAnalyzer &BFR); // Do not implement
|
|
|
|
public:
|
|
BytecodeStdinAnalyzer(BytecodeAnalysis& bca);
|
|
};
|
|
}
|
|
|
|
BytecodeStdinAnalyzer::BytecodeStdinAnalyzer(BytecodeAnalysis& bca ) {
|
|
int BlockSize;
|
|
unsigned char Buffer[4096*4];
|
|
|
|
// Read in all of the data from stdin, we cannot mmap stdin...
|
|
while ((BlockSize = ::read(0 /*stdin*/, Buffer, 4096*4))) {
|
|
if (BlockSize == -1)
|
|
throw ErrnoMessage(errno, "read from standard input");
|
|
|
|
FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
|
|
}
|
|
|
|
if (FileData.empty())
|
|
throw std::string("Standard Input empty!");
|
|
|
|
FileBuf = &FileData[0];
|
|
if (bca.dumpBytecode)
|
|
DumpBytecode(&FileData[0], FileData.size(), bca, "<stdin>");
|
|
AnalyzeBytecode(FileBuf, FileData.size(), bca, "<stdin>");
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Wrapper functions
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AnalyzeBytecodeFile - analyze one file
|
|
void llvm::AnalyzeBytecodeFile(const std::string &Filename,
|
|
BytecodeAnalysis& bca,
|
|
std::string *ErrorStr)
|
|
{
|
|
try {
|
|
if ( Filename != "-" )
|
|
BytecodeFileAnalyzer bfa(Filename,bca);
|
|
else
|
|
BytecodeStdinAnalyzer bsa(bca);
|
|
} catch (std::string &err) {
|
|
if (ErrorStr) *ErrorStr = err;
|
|
}
|
|
}
|
|
|
|
// AnalyzeBytecodeBuffer - analyze a buffer
|
|
void llvm::AnalyzeBytecodeBuffer(
|
|
const unsigned char* Buffer, ///< Pointer to start of bytecode buffer
|
|
unsigned BufferSize, ///< Size of the bytecode buffer
|
|
BytecodeAnalysis& Results, ///< The results of the analysis
|
|
std::string* ErrorStr ///< Errors, if any.
|
|
)
|
|
{
|
|
try {
|
|
BytecodeBufferAnalyzer(Buffer, BufferSize, Results, "<buffer>" );
|
|
} catch (std::string& err ) {
|
|
if ( ErrorStr) *ErrorStr = err;
|
|
}
|
|
}
|
|
|
|
|
|
/// This function prints the contents of rhe BytecodeAnalysis structure in
|
|
/// a human legible form.
|
|
/// @brief Print BytecodeAnalysis structure to an ostream
|
|
void llvm::PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out )
|
|
{
|
|
Out << " Bytecode Analysis of: " << bca.ModuleId << "\n";
|
|
Out << " File Size: " << bca.byteSize << "\n";
|
|
Out << " Number Of Types: " << bca.numTypes << "\n";
|
|
Out << " Number Of Constants: " << bca.numConstants << "\n";
|
|
Out << " Number Of Global Variables: " << bca.numGlobalVars << "\n";
|
|
Out << " Number Of Functions: " << bca.numFunctions << "\n";
|
|
Out << " Number Of Basic Blocks: " << bca.numBasicBlocks << "\n";
|
|
Out << " Number Of Instructions: " << bca.numInstructions << "\n";
|
|
Out << " Number Of Operands: " << bca.numOperands << "\n";
|
|
Out << "Number Of Compaction Tables: " << bca.numCmpctnTables << "\n";
|
|
Out << " Number Of Symbol Tables: " << bca.numSymTab << "\n";
|
|
Out << " Maximum Type Slot Number: " << bca.maxTypeSlot << "\n";
|
|
Out << " Maximum Value Slot Number: " << bca.maxValueSlot << "\n";
|
|
Out << " Bytecode Density: " << bca.density << "\n";
|
|
|
|
if ( bca.detailedResults )
|
|
Out << "Detailed Results Not Implemented Yet.\n";
|
|
|
|
if ( bca.dumpBytecode )
|
|
Out << bca.BytecodeDump;
|
|
}
|
|
|
|
// vim: sw=2
|