mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-26 06:29:20 +00:00
f2e292ce58
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
126 lines
5.5 KiB
C++
126 lines
5.5 KiB
C++
//===-- llvm/Bytecode/Analyzer.h - Analyzer for Bytecode files --*- C++ -*-===//
|
|
//
|
|
// 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 functionality is implemented by the lib/Bytecode/Reader library.
|
|
// It is used to read VM bytecode files from a file or memory buffer
|
|
// and print out a diagnostic analysis of the contents of the file. It is
|
|
// intended for three uses: (a) understanding the bytecode format, (b) ensuring
|
|
// correctness of bytecode format, (c) statistical analysis of generated
|
|
// bytecode files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_BYTECODE_ANALYZER_H
|
|
#define LLVM_BYTECODE_ANALYZER_H
|
|
|
|
#include "llvm/Bytecode/Format.h"
|
|
#include "llvm/Bytecode/Reader.h"
|
|
#include <string>
|
|
#include <map>
|
|
#include <iosfwd>
|
|
|
|
namespace llvm {
|
|
|
|
// Forward declarations
|
|
class Function;
|
|
class Module;
|
|
|
|
/// This structure is used to contain the output of the Bytecode Analysis
|
|
/// library. It simply contains fields to hold each item of the analysis
|
|
/// results.
|
|
/// @brief Bytecode Analysis results structure
|
|
struct BytecodeAnalysis {
|
|
std::string ModuleId; ///< Identification of the module
|
|
unsigned version; ///< The version number of the bytecode file
|
|
unsigned byteSize; ///< The size of the bytecode file in bytes
|
|
unsigned numTypes; ///< The number of types
|
|
unsigned numValues; ///< The number of values
|
|
unsigned numBlocks; ///< The number of *bytecode* blocks
|
|
unsigned numFunctions; ///< The number of functions defined
|
|
unsigned numConstants; ///< The number of constants
|
|
unsigned numGlobalVars; ///< The number of global variables
|
|
unsigned numInstructions; ///< The number of instructions in all functions
|
|
unsigned numBasicBlocks; ///< The number of BBs in all functions
|
|
unsigned numOperands; ///< The number of BBs in all functions
|
|
unsigned numCmpctnTables; ///< The number of compaction tables
|
|
unsigned numSymTab; ///< The number of symbol tables
|
|
unsigned numAlignment; ///< The number of alignment bytes
|
|
unsigned numLibraries; ///< The number of dependent libraries
|
|
unsigned libSize; ///< Number of bytes taken by dep libs.
|
|
unsigned maxTypeSlot; ///< The maximum slot number for types
|
|
unsigned maxValueSlot; ///< The maximum slot number for values
|
|
double fileDensity; ///< Density of file (bytes/definition)
|
|
///< This is the density of the bytecode file. It is the ratio of
|
|
///< the number of bytes to the number of definitions in the file. Smaller
|
|
///< numbers mean the file is more compact (denser). Larger numbers mean
|
|
///< the file is more sparse.
|
|
double globalsDensity; ///< density of global defs (bytes/definition)
|
|
double functionDensity; ///< Average density of functions (bytes/function)
|
|
unsigned instructionSize; ///< Size of instructions in bytes
|
|
unsigned longInstructions;///< Number of instructions > 4 bytes
|
|
|
|
typedef std::map<BytecodeFormat::BytecodeBlockIdentifiers,unsigned>
|
|
BlockSizeMap;
|
|
BlockSizeMap BlockSizes;
|
|
|
|
/// A structure that contains various pieces of information related to
|
|
/// an analysis of a single function.
|
|
struct BytecodeFunctionInfo {
|
|
std::string description; ///< Function type description
|
|
std::string name; ///< Name of function if it has one
|
|
unsigned byteSize; ///< The size of the function in bytecode bytes
|
|
unsigned numInstructions; ///< The number of instructions in the function
|
|
unsigned numBasicBlocks; ///< The number of basic blocks in the function
|
|
unsigned numPhis; ///< Number of Phi Nodes in Instructions
|
|
unsigned numOperands; ///< The number of operands in the function
|
|
double density; ///< Density of function
|
|
unsigned instructionSize; ///< Size of instructions in bytes
|
|
unsigned longInstructions;///< Number of instructions > 4 bytes
|
|
};
|
|
|
|
/// A mapping of function slot numbers to the collected information about
|
|
/// the function.
|
|
std::map<const Function*,BytecodeFunctionInfo> FunctionInfo;
|
|
|
|
/// The content of the progressive verification
|
|
std::string VerifyInfo;
|
|
|
|
/// Flags for what should be done
|
|
bool detailedResults; ///< If true, FunctionInfo has contents
|
|
bool progressiveVerify; ///< If true, VerifyInfo has contents
|
|
};
|
|
|
|
/// This function is the main entry point into the bytecode analysis library. It
|
|
/// allows you to simply provide a \p filename and storage for the \p Results
|
|
/// that will be filled in with the analysis results.
|
|
/// @brief Analyze contents of a bytecode File
|
|
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 prints the contents of rhe BytecodeAnalysis structure in
|
|
/// a human legible form.
|
|
/// @brief Print BytecodeAnalysis structure to an ostream
|
|
void PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out );
|
|
|
|
/// @brief std::ostream inserter for BytecodeAnalysis structure
|
|
inline std::ostream& operator<<(std::ostream& Out, BytecodeAnalysis& bca ) {
|
|
PrintBytecodeAnalysis(bca,Out);
|
|
return Out;
|
|
}
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|