#define READER_INTERNALS_H
#include "llvm/Bytecode/Primitives.h"
-#include "llvm/SymTabValue.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/Instruction.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/Constant.h"
+#include "Support/NonCopyable.h"
#include <map>
#include <utility>
#include <list>
+#include <iostream>
// Enable to trace to figure out what the heck is going on when parsing fails
#define TRACE_LEVEL 0
#if TRACE_LEVEL // ByteCodeReading_TRACEer
-#include "llvm/Assembly/Writer.h"
-#define BCR_TRACE(n, X) if (n < TRACE_LEVEL) cerr << std::string(n*2, ' ') << X
+#define BCR_TRACE(n, X) if (n < TRACE_LEVEL) std::cerr << std::string(n*2, ' ') << X
#else
#define BCR_TRACE(n, X)
#endif
-class BasicBlock;
-class Method;
-class Module;
-class Type;
-class PointerType;
-
typedef unsigned char uchar;
struct RawInst { // The raw fields out of the bytecode stream...
};
};
+
+class ConstantFwdRefs: public NonCopyable {
+ Module* TheModule;
+
+ // GlobalRefs - This maintains a mapping between <Type, Slot #>'s and forward
+ // references to global values or constants. Such values may be referenced
+ // before they are defined, and if so, the temporary object that they
+ // represent is held here.
+ //
+ typedef std::map<std::pair<const Type *, unsigned>,
+ Value*> GlobalRefsType;
+ GlobalRefsType GlobalRefs;
+
+ Value* find (const Type* Ty, unsigned Slot);
+ void insert (const Type* Ty, unsigned Slot, Value* V);
+ void erase (const Type* Ty, unsigned Slot);
+
+public:
+ // sets the current module pointer: needed to insert placeholder globals
+ void VisitingModule (Module* M) { TheModule = M; }
+
+ // get a forward reference to a global or a constant
+ GlobalValue* GetFwdRefToGlobal (const PointerType* PT, unsigned Slot);
+ Constant* GetFwdRefToConstant (const Type* Ty, unsigned Slot);
+
+ // resolve all references to the placeholder (if any) for the given value
+ void ResolveRefsToValue (Value* val, unsigned Slot);
+};
+
+
class BytecodeParser : public AbstractTypeUser {
std::string Error; // Error message string goes here...
public:
std::string getError() const { return Error; }
+ void dump() const {
+ std::cerr << "BytecodeParser instance!\n";
+ }
+
private: // All of this data is transient across calls to ParseBytecode
Module *TheModule; // Current Module being read into...
ValueTable Values, LateResolveValues;
ValueTable ModuleValues, LateResolveModuleValues;
- // GlobalRefs - This maintains a mapping between <Type, Slot #>'s and forward
- // references to global values. Global values may be referenced before they
- // are defined, and if so, the temporary object that they represent is held
- // here.
- //
- typedef std::map<std::pair<const PointerType *, unsigned>,
- GlobalVariable*> GlobalRefsType;
- GlobalRefsType GlobalRefs;
+ // fwdRefs - This manages forward references to global values.
+ ConstantFwdRefs fwdRefs;
// TypesLoaded - This vector mirrors the Values[TypeTyID] plane. It is used
// to deal with forward references to types.
bool getTypeSlot(const Type *Ty, unsigned &Slot);
- // DeclareNewGlobalValue - Patch up forward references to global values in the
- // form of ConstantPointerRefs.
- //
- void DeclareNewGlobalValue(GlobalValue *GV, unsigned Slot);
-
+ // resolveRefsToGlobal -- resolve forward references to a global
+ // resolveRefsToConstant -- resolve forward references to a constant
+ //
+ void resolveRefsToGlobal(GlobalValue* GV, unsigned Slot);
+ void resolveRefsToConstant(Constant* C, unsigned Slot);
+
// refineAbstractType - The callback method is invoked when one of the
// elements of TypeValues becomes more concrete...
//
template<class SuperType>
class PlaceholderDef : public SuperType {
unsigned ID;
+ PlaceholderDef(); // do not implement
public:
PlaceholderDef(const Type *Ty, unsigned id) : SuperType(Ty), ID(id) {}
unsigned getID() { return ID; }
struct BBPlaceHolderHelper : public BasicBlock {
BBPlaceHolderHelper(const Type *Ty) : BasicBlock() {
- assert(Ty->isLabelType());
+ assert(Ty == Type::LabelTy);
}
};
-struct MethPlaceHolderHelper : public Method {
+struct MethPlaceHolderHelper : public Function {
MethPlaceHolderHelper(const Type *Ty)
- : Method(cast<const MethodType>(Ty), true) {
+ : Function(cast<const FunctionType>(Ty), true) {
}
};
+struct ConstantPlaceHolderHelper : public Constant {
+ ConstantPlaceHolderHelper(const Type *Ty)
+ : Constant(Ty) {}
+ virtual bool isNullValue() const { return false; }
+};
+
typedef PlaceholderDef<InstPlaceHolderHelper> DefPHolder;
typedef PlaceholderDef<BBPlaceHolderHelper> BBPHolder;
typedef PlaceholderDef<MethPlaceHolderHelper> MethPHolder;
+typedef PlaceholderDef<ConstantPlaceHolderHelper> ConstPHolder;
+
static inline unsigned getValueIDNumberFromPlaceHolder(Value *Def) {
+ if (isa<Constant>(Def))
+ return ((ConstPHolder*)Def)->getID();
+
+ // else discriminate by type
switch (Def->getType()->getPrimitiveID()) {
- case Type::LabelTyID: return ((BBPHolder*)Def)->getID();
- case Type::MethodTyID: return ((MethPHolder*)Def)->getID();
- default: return ((DefPHolder*)Def)->getID();
+ case Type::LabelTyID: return ((BBPHolder*)Def)->getID();
+ case Type::FunctionTyID: return ((MethPHolder*)Def)->getID();
+ default: return ((DefPHolder*)Def)->getID();
}
}
unsigned &Type, unsigned &Size) {
#if DEBUG_OUTPUT
bool Result = read(Buf, EndBuf, Type) || read(Buf, EndBuf, Size);
- cerr << "StartLoc = " << ((unsigned)Buf & 4095)
+ std::cerr << "StartLoc = " << ((unsigned)Buf & 4095)
<< " Type = " << Type << " Size = " << Size << endl;
return Result;
#else