From: Reid Spencer Date: Fri, 25 Jun 2004 02:32:27 +0000 (+0000) Subject: - Changed Handler.h -> BytecodeHandler.h X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=e5c9df6880b47bd236ecee56f2bed3f118f14bd2;p=oota-llvm.git - Changed Handler.h -> BytecodeHandler.h - Fixed some small coding standard compliance issues in BytecodeHandler.h git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14393 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Bytecode/BytecodeHandler.h b/include/llvm/Bytecode/BytecodeHandler.h new file mode 100644 index 00000000000..3fb958df875 --- /dev/null +++ b/include/llvm/Bytecode/BytecodeHandler.h @@ -0,0 +1,291 @@ +//===-- BytecodeHandler.h - Handle Bytecode Parsing Events ------*- 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 Handler. The handler +// is called by the Bytecode Reader to obtain out-of-band parsing events for +// tasks other then LLVM IR construction. +// +//===----------------------------------------------------------------------===// + +#ifndef BYTECODE_BYTECODEHANDLER_H +#define BYTECODE_BYTECODEHANDLER_H + +#include "llvm/Module.h" + +namespace llvm { + +class ArrayType; +class StructType; +class PointerType; +class ConstantArray; + +/// This class provides the interface for handling bytecode events during +/// reading of bytecode. The methods on this interface are invoked by the +/// BytecodeReader as it discovers the content of a bytecode stream. +/// This class provides a a clear separation of concerns between recognizing +/// the semantic units of a bytecode file (the Reader) and deciding what to do +/// with them (the Handler). +/// +/// The BytecodeReader recognizes the content of the bytecode file and +/// calls the BytecodeHandler methods to let it perform additional tasks. This +/// arrangement allows Bytecode files to be read and handled for a number of +/// purposes simply by creating a subclass of BytecodeHandler. None of the +/// parsing details need to be understood, only the meaning of the calls +/// made on this interface. +/// +/// @see BytecodeHandler +/// @brief Handle Bytecode Parsing Events +class BytecodeHandler { + +/// @name Constructors And Operators +/// @{ +public: + /// @brief Default constructor (empty) + BytecodeHandler() {} + /// @brief Virtual destructor (empty) + virtual ~BytecodeHandler(); + +private: + BytecodeHandler(const BytecodeHandler &); // DO NOT IMPLEMENT + void operator=(const BytecodeHandler &); // DO NOT IMPLEMENT + +/// @} +/// @name Handler Methods +/// @{ +public: + + /// This method is called whenever the parser detects an error in the + /// bytecode formatting. It gives the handler a chance to do something + /// with the error message before the parser throws an exception to + /// terminate the parsing. + /// @brief Handle parsing errors. + virtual void handleError(const std::string& str ); + + /// This method is called at the beginning of a parse before anything is + /// read in order to give the handler a chance to initialize. + /// @brief Handle the start of a bytecode parse + virtual void handleStart( unsigned byteSize ); + + /// This method is called at the end of a parse after everything has been + /// read in order to give the handler a chance to terminate. + /// @brief Handle the end of a bytecode parse + virtual void handleFinish(); + + /// This method is called at the start of a module to indicate that a + /// module is being parsed. + /// @brief Handle the start of a module. + virtual void handleModuleBegin(const std::string& moduleId); + + /// This method is called at the end of a module to indicate that the module + /// previously being parsed has concluded. + /// @brief Handle the end of a module. + virtual void handleModuleEnd( + const std::string& moduleId ///< An identifier for the module + ); + + /// This method is called once the version information has been parsed. It + /// provides the information about the version of the bytecode file being + /// read. + /// @brief Handle the bytecode prolog + virtual void handleVersionInfo( + unsigned char RevisionNum, ///< Byte code revision number + Module::Endianness Endianness, ///< Endianness indicator + Module::PointerSize PointerSize ///< PointerSize indicator + ); + + /// This method is called at the start of a module globals block which + /// contains the global variables and the function placeholders + virtual void handleModuleGlobalsBegin(); + + /// This method is called when a non-initialized global variable is + /// recognized. Its type, constness, and linkage type are provided. + /// @brief Handle a non-initialized global variable + virtual void handleGlobalVariable( + const Type* ElemType, ///< The type of the global variable + bool isConstant, ///< Whether the GV is constant or not + GlobalValue::LinkageTypes,///< The linkage type of the GV + unsigned SlotNum, ///< Slot number of GV + unsigned initSlot ///< Slot number of GV's initializer (0 if none) + ); + + /// This method is called when a new type is recognized. The type is + /// converted from the bytecode and passed to this method. + /// @brief Handle a type + virtual void handleType( + const Type* Ty ///< The type that was just recognized + ); + + /// This method is called when the function prototype for a function is + /// encountered in the module globals block. + virtual void handleFunctionDeclaration( + Function* Func ///< The function being declared + ); + + /// This method is called at the end of the module globals block. + /// @brief Handle end of module globals block. + virtual void handleModuleGlobalsEnd(); + + /// This method is called at the beginning of a compaction table. + /// @brief Handle start of compaction table. + virtual void handleCompactionTableBegin(); + + /// @brief Handle start of a compaction table plane + virtual void handleCompactionTablePlane( + unsigned Ty, ///< The type of the plane (slot number) + unsigned NumEntries ///< The number of entries in the plane + ); + + /// @brief Handle a type entry in the compaction table + virtual void handleCompactionTableType( + unsigned i, ///< Index in the plane of this type + unsigned TypSlot, ///< Slot number for this type + const Type* ///< The type referenced by this slot + ); + + /// @brief Handle a value entry in the compaction table + virtual void handleCompactionTableValue( + unsigned i, ///< Index in the compaction table's type plane + unsigned TypSlot, ///< The slot (plane) of the type of this value + unsigned ValSlot, ///< The global value slot of the value + const Type* ///< The resolved type of the value. + ); + + /// @brief Handle end of a compaction table + virtual void handleCompactionTableEnd(); + + /// @brief Handle start of a symbol table + virtual void handleSymbolTableBegin( + Function* Func, ///< The function to which the ST belongs + SymbolTable* ST ///< The symbol table being filled + ); + + /// @brief Handle start of a symbol table plane + virtual void handleSymbolTablePlane( + unsigned Ty, ///< The slotnum of the type plane + unsigned NumEntries, ///< Number of entries in the plane + const Type* Ty ///< The type of this type plane + ); + + /// @brief Handle a named type in the symbol table + virtual void handleSymbolTableType( + unsigned i, ///< The index of the type in this plane + unsigned slot, ///< Slot number of the named type + const std::string& name ///< Name of the type + ); + + /// @brief Handle a named value in the symbol table + virtual void handleSymbolTableValue( + unsigned i, ///< The index of the value in this plane + unsigned slot, ///< Slot number of the named value + const std::string& name ///< Name of the value. + ); + + /// @brief Handle the end of a symbol table + virtual void handleSymbolTableEnd(); + + /// @brief Handle the beginning of a function body + virtual void handleFunctionBegin( + Function* Func, ///< The function being defined + unsigned Size ///< The size (in bytes) of the function's bytecode + ); + + /// @brief Handle the end of a function body + virtual void handleFunctionEnd( + Function* Func ///< The function whose definition has just finished. + ); + + /// @brief Handle the beginning of a basic block + virtual void handleBasicBlockBegin( + unsigned blocknum ///< The block number of the block + ); + + /// This method is called for each instruction that is parsed. + /// @returns true if the instruction is a block terminating instruction + /// @brief Handle an instruction + virtual bool handleInstruction( + unsigned Opcode, ///< Opcode of the instruction + const Type* iType, ///< Instruction type + std::vector& Operands, ///< Vector of slot # operands + unsigned Length ///< Length of instruction in bc bytes + ); + + /// @brief Handle the end of a basic block + virtual void handleBasicBlockEnd( + unsigned blocknum ///< The block number of the block just finished + ); + + /// @brief Handle start of global constants block. + virtual void handleGlobalConstantsBegin(); + + /// @brief Handle a constant expression + virtual void handleConstantExpression( + unsigned Opcode, ///< Opcode of primary expression operator + const Type* Typ, ///< Type of the expression + std::vector > ArgVec ///< expression args + ); + + /// @brief Handle a constant array + virtual void handleConstantArray( + const ArrayType* AT, ///< Type of the array + std::vector& ElementSlots ///< Slot nums for array values + ); + + /// @brief Handle a constant structure + virtual void handleConstantStruct( + const StructType* ST, ///< Type of the struct + std::vector& ElementSlots ///< Slot nums for struct values + ); + + /// @brief Handle a constant pointer + virtual void handleConstantPointer( + const PointerType* PT, ///< Type of the pointer + unsigned Slot ///< Slot num of initializer value + ); + + /// @brief Handle a constant strings (array special case) + virtual void handleConstantString( + const ConstantArray* CA ///< Type of the string array + ); + + /// @brief Handle a primitive constant value + virtual void handleConstantValue( + Constant * c ///< The constant just defined + ); + + /// @brief Handle the end of the global constants + virtual void handleGlobalConstantsEnd(); + + /// @brief Handle an alignment event + virtual void handleAlignment( + unsigned numBytes ///< The number of bytes added for alignment + ); + + /// @brief Handle a bytecode block + virtual void handleBlock( + unsigned BType, ///< The type of block + const unsigned char* StartPtr, ///< The start of the block + unsigned Size ///< The size of the block + ); + + /// @brief Handle a variable bit rate 32 bit unsigned + virtual void handleVBR32( + unsigned Size ///< Number of bytes the vbr_uint took up + ); + + /// @brief Handle a variable bit rate 64 bit unsigned + virtual void handleVBR64( + unsigned Size ///< Number of byte sthe vbr_uint64 took up + ); +/// @} + +}; + +} +// vim: sw=2 ai +#endif diff --git a/include/llvm/Bytecode/Handler.h b/include/llvm/Bytecode/Handler.h deleted file mode 100644 index 42e881d1f42..00000000000 --- a/include/llvm/Bytecode/Handler.h +++ /dev/null @@ -1,291 +0,0 @@ -//===-- Handler.h - Handle Bytecode Parsing Events --------------*- 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 Handler. The handler -// is caleld by the Bytecode Reader to obtain out-of-band parsing events for -// tasks other then LLVM IR construction. -// -//===----------------------------------------------------------------------===// - -#ifndef BYTECODE_HANDLER_H -#define BYTECODE_HANDLER_H - -#include - -namespace llvm { - -class ArrayType; -class StructType; -class PointerType; -class ConstantArray; - -/// This class provides the interface for handling bytecode events during -/// reading of bytecode. The methods on this interface are invoked by the -/// BytecodeReader as it discovers the content of a bytecode stream. -/// This class provides a a clear separation of concerns between recognizing -/// the semantic units of a bytecode file (the Reader) and deciding what to do -/// with them (the Handler). -/// The BytecodeReader recognizes the content of the bytecode file and -/// calls the BytecodeHandler methods to let it perform additional tasks. This -/// arrangement allows Bytecode files to be read and handled for a number of -/// purposes simply by creating a subclass of BytecodeHandler. None of the -/// parsing details need to be understood, only the meaning of the calls -/// made on this interface. -/// -/// @see BytecodeHandler -/// @brief Handle Bytecode Parsing Events -class BytecodeHandler { - -/// @name Constructors And Operators -/// @{ -public: - /// @brief Default constructor (empty) - BytecodeHandler() {} - /// @brief Virtual destructor (empty) - virtual ~BytecodeHandler() {} - -private: - BytecodeHandler(const BytecodeHandler &); // DO NOT IMPLEMENT - void operator=(const BytecodeHandler &); // DO NOT IMPLEMENT - -/// @} -/// @name Handler Methods -/// @{ -public: - - /// This method is called whenever the parser detects an error in the - /// bytecode formatting. Returning true will cause the parser to keep - /// going, however this is inadvisable in most cases. Returning false will - /// cause the parser to throw the message as a std::string. - /// @brief Handle parsing errors. - virtual void handleError(const std::string& str ); - - /// This method is called at the beginning of a parse before anything is - /// read in order to give the handler a chance to initialize. - /// @brief Handle the start of a bytecode parse - virtual void handleStart(); - - /// This method is called at the end of a parse after everything has been - /// read in order to give the handler a chance to terminate. - /// @brief Handle the end of a bytecode parse - virtual void handleFinish(); - - /// This method is called at the start of a module to indicate that a - /// module is being parsed. - /// @brief Handle the start of a module. - virtual void handleModuleBegin(const std::string& id); - - /// This method is called at the end of a module to indicate that the module - /// previously being parsed has concluded. - /// @brief Handle the end of a module. - virtual void handleModuleEnd( - const std::string& moduleId ///< An identifier for the module - ); - - /// This method is called once the version information has been parsed. It - /// provides the information about the version of the bytecode file being - /// read. - /// @brief Handle the bytecode prolog - virtual void handleVersionInfo( - unsigned char RevisionNum, ///< Byte code revision number - Module::Endianness Endianness, ///< Endianness indicator - Module::PointerSize PointerSize ///< PointerSize indicator - ); - - /// This method is called at the start of a module globals block which - /// contains the global variables and the function placeholders - virtual void handleModuleGlobalsBegin(); - - /// This method is called when a non-initialized global variable is - /// recognized. Its type, constness, and linkage type are provided. - /// @brief Handle a non-initialized global variable - virtual void handleGlobalVariable( - const Type* ElemType, ///< The type of the global variable - bool isConstant, ///< Whether the GV is constant or not - GlobalValue::LinkageTypes,///< The linkage type of the GV - unsigned SlotNum, ///< Slot number of GV - unsigned initSlot ///< Slot number of GV's initializer (0 if none) - ); - - /// This method is called when a new type is recognized. The type is - /// converted from the bytecode and passed to this method. - /// @brief Handle a type - virtual void handleType( - const Type* Ty ///< The type that was just recognized - ); - - /// This method is called when the function prototype for a function is - /// encountered in the module globals block. - virtual void handleFunctionDeclaration( - Function* Func, ///< The function being declared - const FunctionType* FuncType ///< The type of the function - ); - - /// This method is called at the end of the module globals block. - /// @brief Handle end of module globals block. - virtual void handleModuleGlobalsEnd(); - - /// This method is called at the beginning of a compaction table. - /// @brief Handle start of compaction table. - virtual void handleCompactionTableBegin(); - - /// @brief Handle start of a compaction table plane - virtual void handleCompactionTablePlane( - unsigned Ty, ///< The type of the plane (slot number) - unsigned NumEntries ///< The number of entries in the plane - ); - - /// @brief Handle a type entry in the compaction table - virtual void handleCompactionTableType( - unsigned i, ///< Index in the plane of this type - unsigned TypSlot, ///< Slot number for this type - const Type* ///< The type referenced by this slot - ); - - /// @brief Handle a value entry in the compaction table - virtual void handleCompactionTableValue( - unsigned i, ///< Index in the compaction table's type plane - unsigned TypSlot, ///< The slot (plane) of the type of this value - unsigned ValSlot, ///< The global value slot of the value - const Type* ///< The resolved type of the value. - ); - - /// @brief Handle end of a compaction table - virtual void handleCompactionTableEnd(); - - /// @brief Handle start of a symbol table - virtual void handleSymbolTableBegin( - Function* Func, ///< The function to which the ST belongs - SymbolTable* ST ///< The symbol table being filled - ); - - /// @brief Handle start of a symbol table plane - virtual void handleSymbolTablePlane( - unsigned Ty, ///< The slotnum of the type plane - unsigned NumEntries, ///< Number of entries in the plane - const Type* Ty ///< The type of this type plane - ); - - /// @brief Handle a named type in the symbol table - virtual void handleSymbolTableType( - unsigned i, ///< The index of the type in this plane - unsigned slot, ///< Slot number of the named type - const std::string& name ///< Name of the type - ); - - /// @brief Handle a named value in the symbol table - virtual void handleSymbolTableValue( - unsigned i, ///< The index of the value in this plane - unsigned slot, ///< Slot number of the named value - const std::string& name ///< Name of the value. - ); - - /// @brief Handle the end of a symbol table - virtual void handleSymbolTableEnd(); - - /// @brief Handle the beginning of a function body - virtual void handleFunctionBegin( - Function* Func, ///< The function being defined - unsigned Size ///< The size (in bytes) of the function's bytecode - ); - - /// @brief Handle the end of a function body - virtual void handleFunctionEnd( - Function* Func ///< The function whose definition has just finished. - ); - - /// @brief Handle the beginning of a basic block - virtual void handleBasicBlockBegin( - unsigned blocknum ///< The block number of the block - ); - - /// This method is called for each instruction that is parsed. - /// @returns true if the instruction is a block terminating instruction - /// @brief Handle an instruction - virtual bool handleInstruction( - unsigned Opcode, ///< Opcode of the instruction - const Type* iType, ///< Instruction type - std::vector& Operands, ///< Vector of slot # operands - unsigned Length ///< Length of instruction in bc bytes - ); - - /// @brief Handle the end of a basic block - virtual void handleBasicBlockEnd( - unsigned blocknum ///< The block number of the block just finished - ); - - /// @brief Handle start of global constants block. - virtual void handleGlobalConstantsBegin(); - - /// @brief Handle a constant expression - virtual void handleConstantExpression( - unsigned Opcode, ///< Opcode of primary expression operator - const Type* Typ, ///< Type of the expression - std::vector > ArgVec ///< expression args - ); - - /// @brief Handle a constant array - virtual void handleConstantArray( - const ArrayType* AT, ///< Type of the array - std::vector& ElementSlots ///< Slot nums for array values - ); - - /// @brief Handle a constant structure - virtual void handleConstantStruct( - const StructType* ST, ///< Type of the struct - std::vector& ElementSlots ///< Slot nums for struct values - ); - - /// @brief Handle a constant pointer - virtual void handleConstantPointer( - const PointerType* PT, ///< Type of the pointer - unsigned Slot ///< Slot num of initializer value - ); - - /// @brief Handle a constant strings (array special case) - virtual void handleConstantString( - const ConstantArray* CA ///< Type of the string array - ); - - /// @brief Handle a primitive constant value - virtual void handleConstantValue( - Constant * c ///< The constant just defined - ); - - /// @brief Handle the end of the global constants - virtual void handleGlobalConstantsEnd(); - - /// @brief Handle an alignment event - virtual void handleAlignment( - unsigned numBytes ///< The number of bytes added for alignment - ); - - /// @brief Handle a bytecode block - virtual void handleBlock( - unsigned BType, ///< The type of block - const unsigned char* StartPtr, ///< The start of the block - unsigned Size ///< The size of the block - ); - - /// @brief Handle a variable bit rate 32 bit unsigned - virtual void handleVBR32( - unsigned Size ///< Number of bytes the vbr_uint took up - ); - - /// @brief Handle a variable bit rate 64 bit unsigned - virtual void handleVBR64( - unsigned Size ///< Number of byte sthe vbr_uint64 took up - ); -/// @} - -}; - -} -// vim: sw=2 ai -#endif