mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-24 22:32:47 +00:00
6b8a63ae58
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@21704 91177308-0d34-0410-b5e6-96231b3b80d8
325 lines
12 KiB
C++
325 lines
12 KiB
C++
//===-- 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 LLVM_BYTECODE_BYTECODEHANDLER_H
|
|
#define LLVM_BYTECODE_BYTECODEHANDLER_H
|
|
|
|
#include "llvm/Module.h"
|
|
|
|
namespace llvm {
|
|
|
|
class ArrayType;
|
|
class StructType;
|
|
class PointerType;
|
|
class PackedType;
|
|
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).
|
|
///
|
|
/// 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( 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() {}
|
|
|
|
/// 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 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
|
|
/// 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 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* ) {}
|
|
|
|
/// 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
|
|
) {}
|
|
|
|
/// @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 TySlot, ///< The slotnum of the type plane
|
|
unsigned NumEntries, ///< Number of entries in the plane
|
|
const Type* Typ ///< 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<unsigned>& Operands, ///< Vector of slot # operands
|
|
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() {}
|
|
|
|
/// @brief Handle a constant expression
|
|
virtual void handleConstantExpression(
|
|
unsigned Opcode, ///< Opcode of primary expression operator
|
|
std::vector<Constant*> ArgVec, ///< expression args
|
|
Constant* C ///< The constant value
|
|
) {}
|
|
|
|
/// @brief Handle a constant array
|
|
virtual void handleConstantArray(
|
|
const ArrayType* AT, ///< Type of the array
|
|
std::vector<Constant*>& ElementSlots,///< Slot nums for array values
|
|
unsigned TypeSlot, ///< Slot # of type
|
|
Constant* Val ///< The constant value
|
|
) {}
|
|
|
|
/// @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* Val ///< The constant value
|
|
) {}
|
|
|
|
/// @brief Handle a constant packed
|
|
virtual void handleConstantPacked(
|
|
const PackedType* PT, ///< Type of the array
|
|
std::vector<Constant*>& ElementSlots,///< Slot nums for packed values
|
|
unsigned TypeSlot, ///< Slot # of type
|
|
Constant* Val ///< The constant value
|
|
) {}
|
|
|
|
/// @brief Handle a constant pointer
|
|
virtual void handleConstantPointer(
|
|
const PointerType* PT, ///< Type of the pointer
|
|
unsigned Slot, ///< Slot num of initializer value
|
|
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(
|
|
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
|
|
) {}
|
|
/// @}
|
|
|
|
};
|
|
|
|
}
|
|
#endif
|