//===-- BytecodeHandler.h - Handle Bytecode Parsing Events ------*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
+// 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
class ArrayType;
class StructType;
class PointerType;
+class VectorType;
class ConstantArray;
class Module;
/// 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).
+/// 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
/// 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 {
/// 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.
+ /// 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 );
+ 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( Module* Mod, unsigned byteSize );
+ virtual void handleStart( Module* Mod, 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();
+ 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);
+ 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
+ /// 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
- );
+ unsigned char RevisionNum ///< Byte code revision number
+ ) {}
/// This method is called at the start of a module globals block which
/// contains the global variables and the function placeholders
- virtual void handleModuleGlobalsBegin();
+ virtual void handleModuleGlobalsBegin() {}
- /// This method is called when a non-initialized global variable is
+ /// 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(
+ 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
+ GlobalValue::VisibilityTypes,///< The visibility style of the GV
unsigned SlotNum, ///< Slot number of GV
- unsigned initSlot ///< Slot number of GV's initializer (0 if none)
- );
+ unsigned initSlot, ///< Slot number of GV's initializer (0 if none)
+ bool isThreadLocal ///< Whether the GV is thread local or not
+ ) {}
+
+ virtual void handleGlobalAlias(
+ const Type* ElemType,
+ GlobalValue::LinkageTypes Linkage,
+ unsigned TypeSlotNum,
+ unsigned AliaseeSlot) { }
+
+ /// This method is called when a type list is recognized. It simply
+ /// provides the number of types that the list contains. The handler
+ /// should expect that number of calls to handleType.
+ /// @brief Handle a type
+ virtual void handleTypeList(
+ unsigned numEntries ///< The number of entries in the type list
+ ) {}
- /// This method is called when a new type is recognized. The type is
+ /// 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(
+ 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(
+ virtual void handleFunctionDeclaration(
Function* Func ///< The function being declared
- );
+ ) {}
/// This method is called when a global variable is initialized with
/// its constant value. Because of forward referencing, etc. this is
/// done towards the end of the module globals block
- virtual void handleGlobalInitializer(GlobalVariable*, Constant* );
+ virtual void handleGlobalInitializer(GlobalVariable*, Constant* ) {}
+
+ /// This method is called for each dependent library name found
+ /// in the module globals block.
+ virtual void handleDependentLibrary(const std::string& libName) {}
+
+ /// This method is called if the module globals has a non-empty target
+ /// triple
+ virtual void handleTargetTriple(const std::string& triple) {}
/// 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();
+ virtual void handleModuleGlobalsEnd() {}
/// @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
- );
+ virtual void handleTypeSymbolTableBegin(
+ TypeSymbolTable* ST ///< The symbol table being filled
+ ) {}
+
+ /// @brief Handle start of a symbol table
+ virtual void handleValueSymbolTableBegin(
+ Function* Func, ///< The function to which the ST belongs or 0 for Mod
+ ValueSymbolTable* ST ///< The symbol table being filled
+ ) {}
/// @brief Handle a named type in the symbol table
- virtual void handleSymbolTableType(
+ 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(
+ 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.
- );
+ const char *name, unsigned NameLen ///< Name of the value.
+ ) {}
+
+ /// @brief Handle the end of a value symbol table
+ virtual void handleTypeSymbolTableEnd() {}
- /// @brief Handle the end of a symbol table
- virtual void handleSymbolTableEnd();
+ /// @brief Handle the end of a type symbol table
+ virtual void handleValueSymbolTableEnd() {}
/// @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.
+ /// 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<unsigned>& Operands, ///< Vector of slot # operands
+ unsigned *Operands, unsigned NumOps, ///< Vector of slot # operands
+ Instruction *Inst, ///< The resulting instruction
unsigned Length ///< Length of instruction in bc bytes
- );
+ ) { return false; }
/// @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();
+ virtual void handleGlobalConstantsBegin() {}
/// @brief Handle a constant expression
- virtual void handleConstantExpression(
+ virtual void handleConstantExpression(
unsigned Opcode, ///< Opcode of primary expression operator
- std::vector<Constant*> ArgVec, ///< expression args
+ Constant**Args, unsigned NumArgs, ///< expression args
Constant* C ///< The constant value
- );
+ ) {}
/// @brief Handle a constant array
- virtual void handleConstantArray(
+ virtual void handleConstantArray(
const ArrayType* AT, ///< Type of the array
- std::vector<Constant*>& ElementSlots,///< Slot nums for array values
+ Constant**ElementSlots, unsigned NumElts,///< Slot nums for array values
unsigned TypeSlot, ///< Slot # of type
Constant* Val ///< The constant value
- );
+ ) {}
- /// @brief Handle a constant structure
- virtual void handleConstantStruct(
+ /// @brief Handle a constant structure
+ virtual void handleConstantStruct(
const StructType* ST, ///< Type of the struct
- std::vector<Constant*>& ElementSlots,///< Slot nums for struct values
+ Constant**ElementSlots, unsigned NumElts,///< Slot nums for struct values
+ Constant* Val ///< The constant value
+ ) {}
+
+ /// @brief Handle a constant packed
+ virtual void handleConstantVector(
+ const VectorType* PT, ///< Type of the array
+ Constant**ElementSlots, unsigned NumElts,///< Slot nums for packed values
+ unsigned TypeSlot, ///< Slot # of type
Constant* Val ///< The constant value
- );
+ ) {}
/// @brief Handle a constant pointer
- virtual void handleConstantPointer(
+ virtual void handleConstantPointer(
const PointerType* PT, ///< Type of the pointer
unsigned Slot, ///< Slot num of initializer value
- GlobalValue* GV, ///< Referenced global value
- Constant* Val ///< Value of constant
- );
+ GlobalValue* GV ///< Referenced global 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(
+ virtual void handleConstantValue(
Constant * c ///< The constant just defined
- );
+ ) {}
/// @brief Handle the end of the global constants
- virtual void handleGlobalConstantsEnd();
+ 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