mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-26 05:32:25 +00:00
eebac5fee6
lookups instead of linear time lookups. This speeds up bc parsing of a large file from 137.834u 118.256s 4:27.96 to 132.611u 114.436s 4:08.53 with a release build. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23611 91177308-0d34-0410-b5e6-96231b3b80d8
536 lines
20 KiB
C++
536 lines
20 KiB
C++
//===-- Reader.h - Interface To Bytecode Reading ----------------*- 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 header file defines the interface to the Bytecode Reader which is
|
|
// responsible for correctly interpreting bytecode files (backwards compatible)
|
|
// and materializing a module from the bytecode read.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef BYTECODE_PARSER_H
|
|
#define BYTECODE_PARSER_H
|
|
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/GlobalValue.h"
|
|
#include "llvm/Function.h"
|
|
#include "llvm/ModuleProvider.h"
|
|
#include "llvm/Bytecode/Analyzer.h"
|
|
#include <utility>
|
|
#include <map>
|
|
|
|
namespace llvm {
|
|
|
|
class BytecodeHandler; ///< Forward declare the handler interface
|
|
|
|
/// This class defines the interface for parsing a buffer of bytecode. The
|
|
/// parser itself takes no action except to call the various functions of
|
|
/// the handler interface. The parser's sole responsibility is the correct
|
|
/// interpretation of the bytecode buffer. The handler is responsible for
|
|
/// instantiating and keeping track of all values. As a convenience, the parser
|
|
/// is responsible for materializing types and will pass them through the
|
|
/// handler interface as necessary.
|
|
/// @see BytecodeHandler
|
|
/// @brief Bytecode Reader interface
|
|
class BytecodeReader : public ModuleProvider {
|
|
|
|
/// @name Constructors
|
|
/// @{
|
|
public:
|
|
/// @brief Default constructor. By default, no handler is used.
|
|
BytecodeReader(BytecodeHandler* h = 0) {
|
|
decompressedBlock = 0;
|
|
Handler = h;
|
|
}
|
|
|
|
~BytecodeReader() {
|
|
freeState();
|
|
if (decompressedBlock) {
|
|
::free(decompressedBlock);
|
|
decompressedBlock = 0;
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
/// @name Types
|
|
/// @{
|
|
public:
|
|
|
|
/// @brief A convenience type for the buffer pointer
|
|
typedef const unsigned char* BufPtr;
|
|
|
|
/// @brief The type used for a vector of potentially abstract types
|
|
typedef std::vector<PATypeHolder> TypeListTy;
|
|
|
|
/// This type provides a vector of Value* via the User class for
|
|
/// storage of Values that have been constructed when reading the
|
|
/// bytecode. Because of forward referencing, constant replacement
|
|
/// can occur so we ensure that our list of Value* is updated
|
|
/// properly through those transitions. This ensures that the
|
|
/// correct Value* is in our list when it comes time to associate
|
|
/// constants with global variables at the end of reading the
|
|
/// globals section.
|
|
/// @brief A list of values as a User of those Values.
|
|
class ValueList : public User {
|
|
std::vector<Use> Uses;
|
|
public:
|
|
ValueList() : User(Type::VoidTy, Value::ArgumentVal, 0, 0) {}
|
|
|
|
// vector compatibility methods
|
|
unsigned size() const { return getNumOperands(); }
|
|
void push_back(Value *V) {
|
|
Uses.push_back(Use(V, this));
|
|
OperandList = &Uses[0];
|
|
++NumOperands;
|
|
}
|
|
Value *back() const { return Uses.back(); }
|
|
void pop_back() { Uses.pop_back(); --NumOperands; }
|
|
bool empty() const { return NumOperands == 0; }
|
|
virtual void print(std::ostream& os) const {
|
|
for (unsigned i = 0; i < size(); ++i) {
|
|
os << i << " ";
|
|
getOperand(i)->print(os);
|
|
os << "\n";
|
|
}
|
|
}
|
|
};
|
|
|
|
/// @brief A 2 dimensional table of values
|
|
typedef std::vector<ValueList*> ValueTable;
|
|
|
|
/// This map is needed so that forward references to constants can be looked
|
|
/// up by Type and slot number when resolving those references.
|
|
/// @brief A mapping of a Type/slot pair to a Constant*.
|
|
typedef std::map<std::pair<unsigned,unsigned>, Constant*> ConstantRefsType;
|
|
|
|
/// For lazy read-in of functions, we need to save the location in the
|
|
/// data stream where the function is located. This structure provides that
|
|
/// information. Lazy read-in is used mostly by the JIT which only wants to
|
|
/// resolve functions as it needs them.
|
|
/// @brief Keeps pointers to function contents for later use.
|
|
struct LazyFunctionInfo {
|
|
const unsigned char *Buf, *EndBuf;
|
|
LazyFunctionInfo(const unsigned char *B = 0, const unsigned char *EB = 0)
|
|
: Buf(B), EndBuf(EB) {}
|
|
};
|
|
|
|
/// @brief A mapping of functions to their LazyFunctionInfo for lazy reading.
|
|
typedef std::map<Function*, LazyFunctionInfo> LazyFunctionMap;
|
|
|
|
/// @brief A list of global variables and the slot number that initializes
|
|
/// them.
|
|
typedef std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitsList;
|
|
|
|
/// This type maps a typeslot/valueslot pair to the corresponding Value*.
|
|
/// It is used for dealing with forward references as values are read in.
|
|
/// @brief A map for dealing with forward references of values.
|
|
typedef std::map<std::pair<unsigned,unsigned>,Value*> ForwardReferenceMap;
|
|
|
|
/// @}
|
|
/// @name Methods
|
|
/// @{
|
|
public:
|
|
/// @brief Main interface to parsing a bytecode buffer.
|
|
void ParseBytecode(
|
|
const unsigned char *Buf, ///< Beginning of the bytecode buffer
|
|
unsigned Length, ///< Length of the bytecode buffer
|
|
const std::string &ModuleID ///< An identifier for the module constructed.
|
|
);
|
|
|
|
/// @brief Parse all function bodies
|
|
void ParseAllFunctionBodies();
|
|
|
|
/// @brief Parse the next function of specific type
|
|
void ParseFunction(Function* Func) ;
|
|
|
|
/// This method is abstract in the parent ModuleProvider class. Its
|
|
/// implementation is identical to the ParseFunction method.
|
|
/// @see ParseFunction
|
|
/// @brief Make a specific function materialize.
|
|
virtual void materializeFunction(Function *F) {
|
|
LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(F);
|
|
if (Fi == LazyFunctionLoadMap.end()) return;
|
|
ParseFunction(F);
|
|
}
|
|
|
|
/// This method is abstract in the parent ModuleProvider class. Its
|
|
/// implementation is identical to ParseAllFunctionBodies.
|
|
/// @see ParseAllFunctionBodies
|
|
/// @brief Make the whole module materialize
|
|
virtual Module* materializeModule() {
|
|
ParseAllFunctionBodies();
|
|
return TheModule;
|
|
}
|
|
|
|
/// This method is provided by the parent ModuleProvde class and overriden
|
|
/// here. It simply releases the module from its provided and frees up our
|
|
/// state.
|
|
/// @brief Release our hold on the generated module
|
|
Module* releaseModule() {
|
|
// Since we're losing control of this Module, we must hand it back complete
|
|
Module *M = ModuleProvider::releaseModule();
|
|
freeState();
|
|
return M;
|
|
}
|
|
|
|
/// @}
|
|
/// @name Parsing Units For Subclasses
|
|
/// @{
|
|
protected:
|
|
/// @brief Parse whole module scope
|
|
void ParseModule();
|
|
|
|
/// @brief Parse the version information block
|
|
void ParseVersionInfo();
|
|
|
|
/// @brief Parse the ModuleGlobalInfo block
|
|
void ParseModuleGlobalInfo();
|
|
|
|
/// @brief Parse a symbol table
|
|
void ParseSymbolTable( Function* Func, SymbolTable *ST);
|
|
|
|
/// @brief Parse functions lazily.
|
|
void ParseFunctionLazily();
|
|
|
|
/// @brief Parse a function body
|
|
void ParseFunctionBody(Function* Func);
|
|
|
|
/// @brief Parse the type list portion of a compaction table
|
|
void ParseCompactionTypes(unsigned NumEntries);
|
|
|
|
/// @brief Parse a compaction table
|
|
void ParseCompactionTable();
|
|
|
|
/// @brief Parse global types
|
|
void ParseGlobalTypes();
|
|
|
|
/// @brief Parse a basic block (for LLVM 1.0 basic block blocks)
|
|
BasicBlock* ParseBasicBlock(unsigned BlockNo);
|
|
|
|
/// @brief parse an instruction list (for post LLVM 1.0 instruction lists
|
|
/// with blocks differentiated by terminating instructions.
|
|
unsigned ParseInstructionList(
|
|
Function* F ///< The function into which BBs will be inserted
|
|
);
|
|
|
|
/// @brief Parse a single instruction.
|
|
void ParseInstruction(
|
|
std::vector<unsigned>& Args, ///< The arguments to be filled in
|
|
BasicBlock* BB ///< The BB the instruction goes in
|
|
);
|
|
|
|
/// @brief Parse the whole constant pool
|
|
void ParseConstantPool(ValueTable& Values, TypeListTy& Types,
|
|
bool isFunction);
|
|
|
|
/// @brief Parse a single constant value
|
|
Constant* ParseConstantValue(unsigned TypeID);
|
|
|
|
/// @brief Parse a block of types constants
|
|
void ParseTypes(TypeListTy &Tab, unsigned NumEntries);
|
|
|
|
/// @brief Parse a single type constant
|
|
const Type *ParseType();
|
|
|
|
/// @brief Parse a string constants block
|
|
void ParseStringConstants(unsigned NumEntries, ValueTable &Tab);
|
|
|
|
/// @}
|
|
/// @name Data
|
|
/// @{
|
|
private:
|
|
char* decompressedBlock; ///< Result of decompression
|
|
BufPtr MemStart; ///< Start of the memory buffer
|
|
BufPtr MemEnd; ///< End of the memory buffer
|
|
BufPtr BlockStart; ///< Start of current block being parsed
|
|
BufPtr BlockEnd; ///< End of current block being parsed
|
|
BufPtr At; ///< Where we're currently parsing at
|
|
|
|
/// Information about the module, extracted from the bytecode revision number.
|
|
///
|
|
unsigned char RevisionNum; // The rev # itself
|
|
|
|
/// Flags to distinguish LLVM 1.0 & 1.1 bytecode formats (revision #0)
|
|
|
|
/// Revision #0 had an explicit alignment of data only for the
|
|
/// ModuleGlobalInfo block. This was fixed to be like all other blocks in 1.2
|
|
bool hasInconsistentModuleGlobalInfo;
|
|
|
|
/// Revision #0 also explicitly encoded zero values for primitive types like
|
|
/// int/sbyte/etc.
|
|
bool hasExplicitPrimitiveZeros;
|
|
|
|
// Flags to control features specific the LLVM 1.2 and before (revision #1)
|
|
|
|
/// LLVM 1.2 and earlier required that getelementptr structure indices were
|
|
/// ubyte constants and that sequential type indices were longs.
|
|
bool hasRestrictedGEPTypes;
|
|
|
|
/// LLVM 1.2 and earlier had class Type deriving from Value and the Type
|
|
/// objects were located in the "Type Type" plane of various lists in read
|
|
/// by the bytecode reader. In LLVM 1.3 this is no longer the case. Types are
|
|
/// completely distinct from Values. Consequently, Types are written in fixed
|
|
/// locations in LLVM 1.3. This flag indicates that the older Type derived
|
|
/// from Value style of bytecode file is being read.
|
|
bool hasTypeDerivedFromValue;
|
|
|
|
/// LLVM 1.2 and earlier encoded block headers as two uint (8 bytes), one for
|
|
/// the size and one for the type. This is a bit wasteful, especially for
|
|
/// small files where the 8 bytes per block is a large fraction of the total
|
|
/// block size. In LLVM 1.3, the block type and length are encoded into a
|
|
/// single uint32 by restricting the number of block types (limit 31) and the
|
|
/// maximum size of a block (limit 2^27-1=134,217,727). Note that the module
|
|
/// block still uses the 8-byte format so the maximum size of a file can be
|
|
/// 2^32-1 bytes long.
|
|
bool hasLongBlockHeaders;
|
|
|
|
/// LLVM 1.2 and earlier wrote type slot numbers as vbr_uint32. In LLVM 1.3
|
|
/// this has been reduced to vbr_uint24. It shouldn't make much difference
|
|
/// since we haven't run into a module with > 24 million types, but for safety
|
|
/// the 24-bit restriction has been enforced in 1.3 to free some bits in
|
|
/// various places and to ensure consistency. In particular, global vars are
|
|
/// restricted to 24-bits.
|
|
bool has32BitTypes;
|
|
|
|
/// LLVM 1.2 and earlier did not provide a target triple nor a list of
|
|
/// libraries on which the bytecode is dependent. LLVM 1.3 provides these
|
|
/// features, for use in future versions of LLVM.
|
|
bool hasNoDependentLibraries;
|
|
|
|
/// LLVM 1.3 and earlier caused blocks and other fields to start on 32-bit
|
|
/// aligned boundaries. This can lead to as much as 30% bytecode size overhead
|
|
/// in various corner cases (lots of long instructions). In LLVM 1.4,
|
|
/// alignment of bytecode fields was done away with completely.
|
|
bool hasAlignment;
|
|
|
|
// In version 4 and earlier, the bytecode format did not support the 'undef'
|
|
// constant.
|
|
bool hasNoUndefValue;
|
|
|
|
// In version 4 and earlier, the bytecode format did not save space for flags
|
|
// in the global info block for functions.
|
|
bool hasNoFlagsForFunctions;
|
|
|
|
// In version 4 and earlier, there was no opcode space reserved for the
|
|
// unreachable instruction.
|
|
bool hasNoUnreachableInst;
|
|
|
|
/// CompactionTypes - If a compaction table is active in the current function,
|
|
/// this is the mapping that it contains. We keep track of what resolved type
|
|
/// it is as well as what global type entry it is.
|
|
std::vector<std::pair<const Type*, unsigned> > CompactionTypes;
|
|
|
|
/// @brief If a compaction table is active in the current function,
|
|
/// this is the mapping that it contains.
|
|
std::vector<std::vector<Value*> > CompactionValues;
|
|
|
|
/// @brief This vector is used to deal with forward references to types in
|
|
/// a module.
|
|
TypeListTy ModuleTypes;
|
|
|
|
/// @brief This is an inverse mapping of ModuleTypes from the type to an
|
|
/// index. Because refining types causes the index of this map to be
|
|
/// invalidated, any time we refine a type, we clear this cache and recompute
|
|
/// it next time we need it. These entries are ordered by the pointer value.
|
|
std::vector<std::pair<const Type*, unsigned> > ModuleTypeIDCache;
|
|
|
|
/// @brief This vector is used to deal with forward references to types in
|
|
/// a function.
|
|
TypeListTy FunctionTypes;
|
|
|
|
/// When the ModuleGlobalInfo section is read, we create a Function object
|
|
/// for each function in the module. When the function is loaded, after the
|
|
/// module global info is read, this Function is populated. Until then, the
|
|
/// functions in this vector just hold the function signature.
|
|
std::vector<Function*> FunctionSignatureList;
|
|
|
|
/// @brief This is the table of values belonging to the current function
|
|
ValueTable FunctionValues;
|
|
|
|
/// @brief This is the table of values belonging to the module (global)
|
|
ValueTable ModuleValues;
|
|
|
|
/// @brief This keeps track of function level forward references.
|
|
ForwardReferenceMap ForwardReferences;
|
|
|
|
/// @brief The basic blocks we've parsed, while parsing a function.
|
|
std::vector<BasicBlock*> ParsedBasicBlocks;
|
|
|
|
/// This maintains a mapping between <Type, Slot #>'s and forward references
|
|
/// to constants. Such values may be referenced before they are defined, and
|
|
/// if so, the temporary object that they represent is held here. @brief
|
|
/// Temporary place for forward references to constants.
|
|
ConstantRefsType ConstantFwdRefs;
|
|
|
|
/// Constant values are read in after global variables. Because of this, we
|
|
/// must defer setting the initializers on global variables until after module
|
|
/// level constants have been read. In the mean time, this list keeps track
|
|
/// of what we must do.
|
|
GlobalInitsList GlobalInits;
|
|
|
|
// For lazy reading-in of functions, we need to save away several pieces of
|
|
// information about each function: its begin and end pointer in the buffer
|
|
// and its FunctionSlot.
|
|
LazyFunctionMap LazyFunctionLoadMap;
|
|
|
|
/// This stores the parser's handler which is used for handling tasks other
|
|
/// just than reading bytecode into the IR. If this is non-null, calls on
|
|
/// the (polymorphic) BytecodeHandler interface (see llvm/Bytecode/Handler.h)
|
|
/// will be made to report the logical structure of the bytecode file. What
|
|
/// the handler does with the events it receives is completely orthogonal to
|
|
/// the business of parsing the bytecode and building the IR. This is used,
|
|
/// for example, by the llvm-abcd tool for analysis of byte code.
|
|
/// @brief Handler for parsing events.
|
|
BytecodeHandler* Handler;
|
|
|
|
/// @}
|
|
/// @name Implementation Details
|
|
/// @{
|
|
private:
|
|
/// @brief Determines if this module has a function or not.
|
|
bool hasFunctions() { return ! FunctionSignatureList.empty(); }
|
|
|
|
/// @brief Determines if the type id has an implicit null value.
|
|
bool hasImplicitNull(unsigned TyID );
|
|
|
|
/// @brief Converts a type slot number to its Type*
|
|
const Type *getType(unsigned ID);
|
|
|
|
/// @brief Converts a pre-sanitized type slot number to its Type* and
|
|
/// sanitizes the type id.
|
|
inline const Type* getSanitizedType(unsigned& ID );
|
|
|
|
/// @brief Read in and get a sanitized type id
|
|
inline const Type* readSanitizedType();
|
|
|
|
/// @brief Converts a Type* to its type slot number
|
|
unsigned getTypeSlot(const Type *Ty);
|
|
|
|
/// @brief Converts a normal type slot number to a compacted type slot num.
|
|
unsigned getCompactionTypeSlot(unsigned type);
|
|
|
|
/// @brief Gets the global type corresponding to the TypeId
|
|
const Type *getGlobalTableType(unsigned TypeId);
|
|
|
|
/// This is just like getTypeSlot, but when a compaction table is in use,
|
|
/// it is ignored.
|
|
unsigned getGlobalTableTypeSlot(const Type *Ty);
|
|
|
|
/// @brief Get a value from its typeid and slot number
|
|
Value* getValue(unsigned TypeID, unsigned num, bool Create = true);
|
|
|
|
/// @brief Get a value from its type and slot number, ignoring compaction
|
|
/// tables.
|
|
Value *getGlobalTableValue(unsigned TyID, unsigned SlotNo);
|
|
|
|
/// @brief Get a basic block for current function
|
|
BasicBlock *getBasicBlock(unsigned ID);
|
|
|
|
/// @brief Get a constant value from its typeid and value slot.
|
|
Constant* getConstantValue(unsigned typeSlot, unsigned valSlot);
|
|
|
|
/// @brief Convenience function for getting a constant value when
|
|
/// the Type has already been resolved.
|
|
Constant* getConstantValue(const Type *Ty, unsigned valSlot) {
|
|
return getConstantValue(getTypeSlot(Ty), valSlot);
|
|
}
|
|
|
|
/// @brief Insert a newly created value
|
|
unsigned insertValue(Value *V, unsigned Type, ValueTable &Table);
|
|
|
|
/// @brief Insert the arguments of a function.
|
|
void insertArguments(Function* F );
|
|
|
|
/// @brief Resolve all references to the placeholder (if any) for the
|
|
/// given constant.
|
|
void ResolveReferencesToConstant(Constant *C, unsigned Typ, unsigned Slot);
|
|
|
|
/// @brief Release our memory.
|
|
void freeState() {
|
|
freeTable(FunctionValues);
|
|
freeTable(ModuleValues);
|
|
}
|
|
|
|
/// @brief Free a table, making sure to free the ValueList in the table.
|
|
void freeTable(ValueTable &Tab) {
|
|
while (!Tab.empty()) {
|
|
delete Tab.back();
|
|
Tab.pop_back();
|
|
}
|
|
}
|
|
|
|
inline void error(std::string errmsg);
|
|
|
|
BytecodeReader(const BytecodeReader &); // DO NOT IMPLEMENT
|
|
void operator=(const BytecodeReader &); // DO NOT IMPLEMENT
|
|
|
|
/// @}
|
|
/// @name Reader Primitives
|
|
/// @{
|
|
private:
|
|
|
|
/// @brief Is there more to parse in the current block?
|
|
inline bool moreInBlock();
|
|
|
|
/// @brief Have we read past the end of the block
|
|
inline void checkPastBlockEnd(const char * block_name);
|
|
|
|
/// @brief Align to 32 bits
|
|
inline void align32();
|
|
|
|
/// @brief Read an unsigned integer as 32-bits
|
|
inline unsigned read_uint();
|
|
|
|
/// @brief Read an unsigned integer with variable bit rate encoding
|
|
inline unsigned read_vbr_uint();
|
|
|
|
/// @brief Read an unsigned integer of no more than 24-bits with variable
|
|
/// bit rate encoding.
|
|
inline unsigned read_vbr_uint24();
|
|
|
|
/// @brief Read an unsigned 64-bit integer with variable bit rate encoding.
|
|
inline uint64_t read_vbr_uint64();
|
|
|
|
/// @brief Read a signed 64-bit integer with variable bit rate encoding.
|
|
inline int64_t read_vbr_int64();
|
|
|
|
/// @brief Read a string
|
|
inline std::string read_str();
|
|
|
|
/// @brief Read a float value
|
|
inline void read_float(float& FloatVal);
|
|
|
|
/// @brief Read a double value
|
|
inline void read_double(double& DoubleVal);
|
|
|
|
/// @brief Read an arbitrary data chunk of fixed length
|
|
inline void read_data(void *Ptr, void *End);
|
|
|
|
/// @brief Read a bytecode block header
|
|
inline void read_block(unsigned &Type, unsigned &Size);
|
|
|
|
/// @brief Read a type identifier and sanitize it.
|
|
inline bool read_typeid(unsigned &TypeId);
|
|
|
|
/// @brief Recalculate type ID for pre 1.3 bytecode files.
|
|
inline bool sanitizeTypeId(unsigned &TypeId );
|
|
/// @}
|
|
};
|
|
|
|
/// @brief A function for creating a BytecodeAnalzer as a handler
|
|
/// for the Bytecode reader.
|
|
BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
|
|
std::ostream* output );
|
|
|
|
|
|
} // End llvm namespace
|
|
|
|
// vim: sw=2
|
|
#endif
|