//===-- Reader.h - Interface To Bytecode Reading ----------------*- 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 Reader which is
+// 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.
//
/// 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
+/// 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
/// @{
public:
/// @brief Default constructor. By default, no handler is used.
- BytecodeReader(BytecodeHandler* h = 0) {
+ BytecodeReader(BytecodeHandler* h = 0) {
decompressedBlock = 0;
Handler = h;
}
- ~BytecodeReader() {
- freeState();
+ ~BytecodeReader() {
+ freeState();
if (decompressedBlock) {
::free(decompressedBlock);
decompressedBlock = 0;
/// constants with global variables at the end of reading the
/// globals section.
/// @brief A list of values as a User of those Values.
- struct ValueList : public User {
- ValueList() : User(Type::VoidTy, Value::ValueListVal) {}
+ 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) { Operands.push_back(Use(V, this)); }
- Value *back() const { return Operands.back(); }
- void pop_back() { Operands.pop_back(); }
- bool empty() const { return Operands.empty(); }
- // must override this
+ 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++ ) {
+ 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
+ /// 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<const Type*,unsigned>, Constant*> ConstantRefsType;
+ 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.
+ /// resolve functions as it needs them.
/// @brief Keeps pointers to function contents for later use.
struct LazyFunctionInfo {
const unsigned char *Buf, *EndBuf;
}
/// This method is abstract in the parent ModuleProvider class. Its
- /// implementation is identical to ParseAllFunctionBodies.
+ /// implementation is identical to ParseAllFunctionBodies.
/// @see ParseAllFunctionBodies
/// @brief Make the whole module materialize
virtual Module* materializeModule() {
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
);
/// @brief Parse the whole constant pool
- void ParseConstantPool(ValueTable& Values, TypeListTy& Types,
+ void ParseConstantPool(ValueTable& Values, TypeListTy& Types,
bool isFunction);
/// @brief Parse a single constant value
/// @name Data
/// @{
private:
- char* decompressedBlock; ///< Result of decompression
+ 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
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
+ /// 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
+ /// 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;
// unreachable instruction.
bool hasNoUnreachableInst;
- // In version 5, basic blocks have a minimum index of 0 whereas all the
- // other primitives have a minimum index of 1 (because 0 is the "null"
- // value. In version 5, we made this consistent.
- bool hasInconsistentBBSlotNums;
-
- // In version 5, the types SByte and UByte were encoded as vbr_uint so that
- // signed values > 63 and unsigned values >127 would be encoded as two
- // bytes. In version 5, they are encoded directly in a single byte.
- bool hasVBRByteTypes;
-
- // In version 5, modules begin with a "Module Block" which encodes a 4-byte
- // integer value 0x01 to identify the module block. This is unnecessary and
- // removed in version 5.
- bool hasUnnecessaryModuleBlockId;
-
/// 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.
// 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
+ /// 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.
const Type *getGlobalTableType(unsigned TypeId);
/// This is just like getTypeSlot, but when a compaction table is in use,
- /// it is ignored.
+ /// 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 Insert the arguments of a function.
void insertArguments(Function* F );
- /// @brief Resolve all references to the placeholder (if any) for the
+ /// @brief Resolve all references to the placeholder (if any) for the
/// given constant.
- void ResolveReferencesToConstant(Constant *C, unsigned Slot);
+ void ResolveReferencesToConstant(Constant *C, unsigned Typ, unsigned Slot);
/// @brief Release our memory.
void freeState() {
/// @brief A function for creating a BytecodeAnalzer as a handler
/// for the Bytecode reader.
-BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
+BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
std::ostream* output );
projects / oota-llvm.git / blobdiff