diff options
Diffstat (limited to 'lib/Bytecode/Reader/Reader.h')
| -rw-r--r-- | lib/Bytecode/Reader/Reader.h | 491 |
1 files changed, 0 insertions, 491 deletions
diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h deleted file mode 100644 index 95cf58c2b3..0000000000 --- a/lib/Bytecode/Reader/Reader.h +++ /dev/null @@ -1,491 +0,0 @@ -//===-- 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/ModuleProvider.h" -#include "llvm/Bytecode/Analyzer.h" -#include "llvm/ADT/SmallVector.h" -#include <utility> -#include <setjmp.h> - -namespace llvm { - -// Forward declarations -class BytecodeHandler; -class TypeSymbolTable; -class ValueSymbolTable; - -/// 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 { - SmallVector<Use, 32> 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; - - /// @brief A list of global aliases and the slot number for constant aliasees - typedef std::vector<std::pair<GlobalAlias*, unsigned> > AliaseeList; - - /// 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: - 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. - BCDecompressor_t *Decompressor = 0, ///< Optional decompressor. - std::string* ErrMsg = 0 ///< Optional place for error message - ); - - /// @brief Parse all function bodies - bool ParseAllFunctionBodies(std::string* ErrMsg); - - /// @brief Parse the next function of specific type - bool ParseFunction(Function* Func, std::string* ErrMsg); - - /// 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 bool materializeFunction(Function *F, std::string *ErrMsg = 0) { - // If it already is material, ignore the request. - if (!F->hasNotBeenReadFromBytecode()) return false; - - assert(LazyFunctionLoadMap.count(F) && - "not materialized but I don't know about it?"); - if (ParseFunction(F,ErrMsg)) - return true; - return false; - } - - /// dematerializeFunction - If the given function is read in, and if the - /// module provider supports it, release the memory for the function, and set - /// it up to be materialized lazily. If the provider doesn't support this - /// capability, this method is a noop. - /// - virtual void dematerializeFunction(Function *F) { - // If the function is not materialized, or if it is a prototype, ignore. - if (F->hasNotBeenReadFromBytecode() || - F->isDeclaration()) - return; - - // Just forget the function body, we can remat it later. - F->deleteBody(); - F->setLinkage(GlobalValue::GhostLinkage); - } - - /// 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(std::string *ErrMsg = 0) { - if (ParseAllFunctionBodies(ErrMsg)) - return 0; - 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(std::string *ErrInfo = 0) { - // Since we're losing control of this Module, we must hand it back complete - Module *M = ModuleProvider::releaseModule(ErrInfo); - 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 value symbol table - void ParseTypeSymbolTable(TypeSymbolTable *ST); - - /// @brief Parse a value symbol table - void ParseValueSymbolTable(Function* Func, ValueSymbolTable *ST); - - /// @brief Parse functions lazily. - void ParseFunctionLazily(); - - /// @brief Parse a function body - void ParseFunctionBody(Function* Func); - - /// @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( - SmallVector <unsigned, 8>& 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 pool value - Value *ParseConstantPoolValue(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 list of parameter attributes - ParamAttrsList *ParseParamAttrsList(); - - /// @brief Parse a string constants block - void ParseStringConstants(unsigned NumEntries, ValueTable &Tab); - - /// @brief Release our memory. - void freeState() { - freeTable(FunctionValues); - freeTable(ModuleValues); - } - -/// @} -/// @name Data -/// @{ -private: - std::string ErrorMsg; ///< A place to hold an error message through longjmp - jmp_buf context; ///< Where to return to if an error occurs. - 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 - - /// @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; - - /// Constant values are read in after global aliases. Because of this, we must - /// defer setting the constant aliasees until after module level constants - /// have been read. In the mean time, this list keeps track of what we must - /// do. - AliaseeList Aliasees; - - // 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 Read in a type id and turn it into a Type* - inline const Type* readType(); - - /// @brief Converts a Type* to its type slot number - unsigned getTypeSlot(const Type *Ty); - - /// @brief Gets the global type corresponding to the TypeId - const Type *getGlobalTableType(unsigned TypeId); - - /// @brief Get a value from its typeid and slot number - Value* getValue(unsigned TypeID, unsigned num, bool Create = true); - - /// @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 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(const std::string& errmsg); - - BytecodeReader(const BytecodeReader &); // DO NOT IMPLEMENT - void operator=(const BytecodeReader &); // DO NOT IMPLEMENT - - // This enum provides the values of the well-known type slots that are always - // emitted as the first few types in the table by the BytecodeWriter class. - enum WellKnownTypeSlots { - VoidTypeSlot = 0, ///< TypeID == VoidTyID - FloatTySlot = 1, ///< TypeID == FloatTyID - DoubleTySlot = 2, ///< TypeID == DoubleTyID - LabelTySlot = 3, ///< TypeID == LabelTyID - BoolTySlot = 4, ///< TypeID == IntegerTyID, width = 1 - Int8TySlot = 5, ///< TypeID == IntegerTyID, width = 8 - Int16TySlot = 6, ///< TypeID == IntegerTyID, width = 16 - Int32TySlot = 7, ///< TypeID == IntegerTyID, width = 32 - Int64TySlot = 8 ///< TypeID == IntegerTyID, width = 64 - }; - -/// @} -/// @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(); - inline void read_str(SmallVectorImpl<char> &StrData); - - /// @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); -/// @} -}; - -} // End llvm namespace - -// vim: sw=2 -#endif |