6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-09-27 15:57:13 +00:00
Code Issues Projects Releases Wiki Activity

* Remove support for internal constant pool

Browse Source 
* Support globally unique constants
* Support recursive and forward referenced types
* Support abstract types
* Add new BCR_TRACE macro to enable debugging of why the bytecode reader
  occasionally refuses to read something


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@448 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2001-09-07 16:37:43 +00:00
parent 007377f381
commit 1d670cc402
4 changed files with 239 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
lib/Bytecode/Reader/ConstantReader.cpp
View File

@ -13,86 +13,158 @@
#include "llvm/ConstPoolVals.h"
#include "llvm/DerivedTypes.h"
#include "ReaderInternals.h"
#include <algorithm>
bool BytecodeParser::parseTypeConstant(const uchar *&Buf, const uchar *EndBuf,
ConstPoolVal *&V) {
const Type *Val = 0;
const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
const uchar *EndBuf) {
unsigned PrimType;
if (read_vbr(Buf, EndBuf, PrimType)) return failure(true);
if (read_vbr(Buf, EndBuf, PrimType)) return failure<const Type*>(0);
if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType))) {
V = new ConstPoolType(Val); // It's just a primitive ID.
return false;
}
const Type *Val = 0;
if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
return Val;
switch (PrimType) {
case Type::MethodTyID: {
unsigned Typ;
if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
const Type *RetType = getType(Typ);
if (RetType == 0) return failure(true);
if (RetType == 0) return failure(Val);
unsigned NumParams;
if (read_vbr(Buf, EndBuf, NumParams)) return failure(true);
if (read_vbr(Buf, EndBuf, NumParams)) return failure(Val);
MethodType::ParamTypes Params;
vector<const Type*> Params;
while (NumParams--) {
if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
const Type *Ty = getType(Typ);
if (Ty == 0) return failure(true);
if (Ty == 0) return failure(Val);
Params.push_back(Ty);
}
Val = MethodType::getMethodType(RetType, Params);
Val = MethodType::get(RetType, Params);
break;
}
case Type::ArrayTyID: {
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(true);
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
const Type *ElementType = getType(ElTyp);
if (ElementType == 0) return failure(true);
if (ElementType == 0) return failure(Val);
int NumElements;
if (read_vbr(Buf, EndBuf, NumElements)) return failure(true);
Val = ArrayType::getArrayType(ElementType, NumElements);
if (read_vbr(Buf, EndBuf, NumElements)) return failure(Val);
Val = ArrayType::get(ElementType, NumElements);
break;
}
case Type::StructTyID: {
unsigned Typ;
StructType::ElementTypes Elements;
vector<const Type*> Elements;
if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
while (Typ) { // List is terminated by void/0 typeid
const Type *Ty = getType(Typ);
if (Ty == 0) return failure(true);
if (Ty == 0) return failure(Val);
Elements.push_back(Ty);
if (read_vbr(Buf, EndBuf, Typ)) return failure(true);
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
}
Val = StructType::getStructType(Elements);
Val = StructType::get(Elements);
break;
}
case Type::PointerTyID: {
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(true);
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
const Type *ElementType = getType(ElTyp);
if (ElementType == 0) return failure(true);
Val = PointerType::getPointerType(ElementType);
if (ElementType == 0) return failure(Val);
Val = PointerType::get(ElementType);
break;
}
default:
cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to deserialize"
<< " primitive Type " << PrimType << "\n";
return failure(true);
return failure(Val);
}
V = new ConstPoolType(Val);
return Val;
}
// refineAbstractType - The callback method is invoked when one of the
// elements of TypeValues becomes more concrete...
//
void BytecodeParser::refineAbstractType(const DerivedType *OldType,
const Type *NewType) {
TypeValuesListTy::iterator I = find(MethodTypeValues.begin(),
MethodTypeValues.end(), OldType);
if (I == MethodTypeValues.end()) {
I = find(ModuleTypeValues.begin(), ModuleTypeValues.end(), OldType);
assert(I != ModuleTypeValues.end() &&
"Can't refine a type I don't know about!");
}
*I = NewType; // Update to point to new, more refined type.
}
// parseTypeConstants - We have to use this wierd code to handle recursive
// types. We know that recursive types will only reference the current slab of
// values in the type plane, but they can forward reference types before they
// have been read. For example, Type #0 might be '{ Ty#1 }' and Type #1 might
// be 'Ty#0*'. When reading Type #0, type number one doesn't exist. To fix
// this ugly problem, we pesimistically insert an opaque type for each type we
// are about to read. This means that forward references will resolve to
// something and when we reread the type later, we can replace the opaque type
// with a new resolved concrete type.
//
bool BytecodeParser::parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
TypeValuesListTy &Tab,
unsigned NumEntries) {
assert(Tab.size() == 0 && "I think table should always be empty here!"
"This should simplify later code");
// Record the base, starting level that we will begin with.
unsigned BaseLevel = Tab.size();
// Insert a bunch of opaque types to be resolved later...
for (unsigned i = 0; i < NumEntries; i++)
Tab.push_back(PATypeHandle<Type>(OpaqueType::get(), this));
// Loop through reading all of the types. Forward types will make use of the
// opaque types just inserted.
//
for (unsigned i = 0; i < NumEntries; i++) {
const Type *NewTy = parseTypeConstant(Buf, EndBuf);
if (NewTy == 0) return failure(true);
BCR_TRACE(4, "Read Type Constant: '" << NewTy << "'\n");
// Don't insertValue the new type... instead we want to replace the opaque
// type with the new concrete value...
//
// Refine the abstract type to the new type. This causes all uses of the
// abstract type to use the newty. This also will cause the opaque type
// to be deleted...
//
// FIXME when types are not const
const_cast<DerivedType*>(Tab[i+BaseLevel]->castDerivedTypeAsserting())->refineAbstractTypeTo(NewTy);
// This should have replace the old opaque type with the new type in the
// value table...
assert(Tab[i+BaseLevel] == NewTy && "refineAbstractType didn't work!");
}
BCR_TRACE(5, "Resulting types:\n");
for (unsigned i = 0; i < NumEntries; i++) {
BCR_TRACE(5, Tab[i+BaseLevel]->castTypeAsserting() << "\n");
}
return false;
}
bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
const uchar *EndBuf,
const Type *Ty, ConstPoolVal *&V) {
@ -101,7 +173,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
unsigned Val;
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
if (Val != 0 && Val != 1) return failure(true);
V = new ConstPoolBool(Val == 1);
V = ConstPoolBool::get(Val == 1);
break;
}
@ -111,14 +183,14 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
unsigned Val;
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
if (!ConstPoolUInt::isValueValidForType(Ty, Val)) return failure(true);
V = new ConstPoolUInt(Ty, Val);
V = ConstPoolUInt::get(Ty, Val);
break;
}
case Type::ULongTyID: {
uint64_t Val;
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
V = new ConstPoolUInt(Ty, Val);
V = ConstPoolUInt::get(Ty, Val);
break;
}
@ -128,34 +200,34 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
int Val;
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
if (!ConstPoolSInt::isValueValidForType(Ty, Val)) return failure(true);
V = new ConstPoolSInt(Ty, Val);
V = ConstPoolSInt::get(Ty, Val);
break;
}
case Type::LongTyID: {
int64_t Val;
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
V = new ConstPoolSInt(Ty, Val);
V = ConstPoolSInt::get(Ty, Val);
break;
}
case Type::FloatTyID: {
float F;
if (input_data(Buf, EndBuf, &F, &F+1)) return failure(true);
V = new ConstPoolFP(Ty, F);
V = ConstPoolFP::get(Ty, F);
break;
}
case Type::DoubleTyID: {
double Val;
if (input_data(Buf, EndBuf, &Val, &Val+1)) return failure(true);
V = new ConstPoolFP(Ty, Val);
V = ConstPoolFP::get(Ty, Val);
break;
}
case Type::TypeTyID:
if (parseTypeConstant(Buf, EndBuf, V)) return failure(true);
break;
assert(0 && "Type constants should be handled seperately!!!");
abort();
case Type::ArrayTyID: {
const ArrayType *AT = (const ArrayType*)Ty;
@ -173,7 +245,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
if (!V || !V->isConstant()) return failure(true);
Elements.push_back((ConstPoolVal*)V);
}
V = new ConstPoolArray(AT, Elements);
V = ConstPoolArray::get(AT, Elements);
break;
}
@ -191,7 +263,7 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
Elements.push_back((ConstPoolVal*)V);
}
V = new ConstPoolStruct(ST, Elements);
V = ConstPoolStruct::get(ST, Elements);
break;
}
@ -201,12 +273,13 @@ bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
<< Ty->getName() << "'\n";
return failure(true);
}
return false;
}
bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
SymTabValue::ConstantPoolType &CP,
ValueTable &Tab) {
ValueTable &Tab,
TypeValuesListTy &TypeTab) {
while (Buf < EndBuf) {
unsigned NumEntries, Typ;
@ -214,16 +287,17 @@ bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
read_vbr(Buf, EndBuf, Typ)) return failure(true);
const Type *Ty = getType(Typ);
if (Ty == 0) return failure(true);
BCR_TRACE(3, "Type: '" << Ty << "' NumEntries: " << NumEntries << "\n");
for (unsigned i = 0; i < NumEntries; i++) {
ConstPoolVal *I;
if (parseConstPoolValue(Buf, EndBuf, Ty, I)) return failure(true);
#if 0
cerr << " Read const value: <" << I->getType()->getName()
<< ">: " << I->getStrValue() << endl;
#endif
insertValue(I, Tab);
CP.insert(I);
if (Typ == Type::TypeTyID) {
if (parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries)) return true;
} else {
for (unsigned i = 0; i < NumEntries; i++) {
ConstPoolVal *I;
if (parseConstPoolValue(Buf, EndBuf, Ty, I)) return failure(true);
BCR_TRACE(4, "Read Constant: '" << I << "'\n");
insertValue(I, Tab);
}
}
}

2
lib/Bytecode/Reader/InstructionReader.cpp
View File

@ -82,7 +82,7 @@ bool BytecodeParser::ParseRawInst(const uchar *&Buf, const uchar *EndBuf,
#if 0
cerr << "NO: " << Result.NumOperands << " opcode: " << Result.Opcode
<< " Ty: " << Result.Ty->getName() << " arg1: " << Result.Arg1
<< " Ty: " << Result.Ty->getDescription() << " arg1: " << Result.Arg1
<< " arg2: " << Result.Arg2 << " arg3: " << Result.Arg3 << endl;
#endif
return false;

134
lib/Bytecode/Reader/Reader.cpp
View File

@ -29,9 +29,17 @@ bool BytecodeParser::getTypeSlot(const Type *Ty, unsigned &Slot) {
if (Ty->isPrimitiveType()) {
Slot = Ty->getPrimitiveID();
} else {
TypeMapType::iterator I = TypeMap.find(Ty);
if (I == TypeMap.end()) return failure(true); // Didn't find type!
Slot = I->second;
// Check the method level types first...
TypeValuesListTy::iterator I = find(MethodTypeValues.begin(),
MethodTypeValues.end(), Ty);
if (I != MethodTypeValues.end()) {
Slot = FirstDerivedTyID+ModuleTypeValues.size()+
(&*I - &MethodTypeValues[0]);
} else {
I = find(ModuleTypeValues.begin(), ModuleTypeValues.end(), Ty);
if (I == ModuleTypeValues.end()) return true; // Didn't find type!
Slot = FirstDerivedTyID + (&*I - &ModuleTypeValues[0]);
}
}
//cerr << "getTypeSlot '" << Ty->getName() << "' = " << Slot << endl;
return false;
@ -46,32 +54,20 @@ const Type *BytecodeParser::getType(unsigned ID) {
const Value *D = getValue(Type::TypeTy, ID, false);
if (D == 0) return failure<const Type*>(0);
assert(D->getType() == Type::TypeTy);
return ((const ConstPoolType*)D->castConstantAsserting())->getValue();
return D->castTypeAsserting();
}
bool BytecodeParser::insertValue(Value *Def, vector<ValueList> &ValueTab) {
bool BytecodeParser::insertValue(Value *Val, vector<ValueList> &ValueTab) {
unsigned type;
if (getTypeSlot(Def->getType(), type)) return failure(true);
if (getTypeSlot(Val->getType(), type)) return failure(true);
assert(type != Type::TypeTyID && "Types should never be insertValue'd!");
if (ValueTab.size() <= type)
ValueTab.resize(type+1, ValueList());
//cerr << "insertValue Values[" << type << "][" << ValueTab[type].size()
// << "] = " << Def << endl;
if (type == Type::TypeTyID && Def->isConstant()) {
const Type *Ty = ((const ConstPoolType*)Def)->getValue();
unsigned ValueOffset = FirstDerivedTyID;
if (&ValueTab == &Values) // Take into consideration module level types
ValueOffset += ModuleValues[type].size();
if (TypeMap.find(Ty) == TypeMap.end())
TypeMap[Ty] = ValueTab[type].size()+ValueOffset;
}
ValueTab[type].push_back(Def);
// << "] = " << Val << endl;
ValueTab[type].push_back(Val);
return false;
}
@ -83,15 +79,27 @@ Value *BytecodeParser::getValue(const Type *Ty, unsigned oNum, bool Create) {
if (getTypeSlot(Ty, type)) return failure<Value*>(0); // TODO: true
if (type == Type::TypeTyID) { // The 'type' plane has implicit values
assert(Create == false);
const Type *T = Type::getPrimitiveType((Type::PrimitiveID)Num);
if (T) return (Value*)T; // Asked for a primitive type...
// Otherwise, derived types need offset...
Num -= FirstDerivedTyID;
// Is it a module level type?
if (Num < ModuleTypeValues.size())
return (Value*)(const Type*)ModuleTypeValues[Num];
// Nope, is it a method level type?
Num -= ModuleTypeValues.size();
if (Num < MethodTypeValues.size())
return (Value*)(const Type*)MethodTypeValues[Num];
return 0;
}
if (ModuleValues.size() > type) {
if (ModuleValues[type].size() > Num)
if (type < ModuleValues.size()) {
if (Num < ModuleValues[type].size())
return ModuleValues[type][Num];
Num -= ModuleValues[type].size();
}
@ -153,22 +161,25 @@ bool BytecodeParser::ParseBasicBlock(const uchar *&Buf, const uchar *EndBuf,
BB = new BasicBlock();
while (Buf < EndBuf) {
Instruction *Def;
if (ParseInstruction(Buf, EndBuf, Def)) {
Instruction *Inst;
if (ParseInstruction(Buf, EndBuf, Inst)) {
delete BB;
return failure(true);
}
if (Def == 0) { delete BB; return failure(true); }
if (insertValue(Def, Values)) { delete BB; return failure(true); }
if (Inst == 0) { delete BB; return failure(true); }
if (insertValue(Inst, Values)) { delete BB; return failure(true); }
BB->getInstList().push_back(Def);
BB->getInstList().push_back(Inst);
BCR_TRACE(4, Inst);
}
return false;
}
bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf,
SymbolTable *ST) {
while (Buf < EndBuf) {
// Symtab block header: [num entries][type id number]
unsigned NumEntries, Typ;
@ -177,6 +188,9 @@ bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
const Type *Ty = getType(Typ);
if (Ty == 0) return failure(true);
BCR_TRACE(3, "Plane Type: '" << Ty << "' with " << NumEntries <<
" entries\n");
for (unsigned i = 0; i < NumEntries; ++i) {
// Symtab entry: [def slot #][name]
unsigned slot;
@ -186,8 +200,14 @@ bool BytecodeParser::ParseSymbolTable(const uchar *&Buf, const uchar *EndBuf) {
return failure(true);
Value *D = getValue(Ty, slot, false); // Find mapping...
if (D == 0) return failure(true);
D->setName(Name);
if (D == 0) {
BCR_TRACE(3, "FAILED LOOKUP: Slot #" << slot << endl);
return failure(true);
}
BCR_TRACE(4, "Map: '" << Name << "' to #" << slot << ":" << D;
if (!D->isInstruction()) cerr << endl);
D->setName(Name, ST);
}
}
@ -207,6 +227,8 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
MethodSignatureList.pop_front();
Method *M = new Method(MTy);
BCR_TRACE(2, "METHOD TYPE: " << MTy << endl);
const MethodType::ParamTypes &Params = MTy->getParamTypes();
for (MethodType::ParamTypes::const_iterator It = Params.begin();
It != Params.end(); ++It) {
@ -222,17 +244,17 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
switch (Type) {
case BytecodeFormat::ConstantPool:
if (ParseConstantPool(Buf, Buf+Size, M->getConstantPool(), Values)) {
cerr << "Error reading constant pool!\n";
BCR_TRACE(2, "BLOCK BytecodeFormat::ConstantPool: {\n");
if (ParseConstantPool(Buf, Buf+Size, Values, MethodTypeValues)) {
delete M; return failure(true);
}
break;
case BytecodeFormat::BasicBlock: {
BCR_TRACE(2, "BLOCK BytecodeFormat::BasicBlock: {\n");
BasicBlock *BB;
if (ParseBasicBlock(Buf, Buf+Size, BB) ||
insertValue(BB, Values)) {
cerr << "Error parsing basic block!\n";
delete M; return failure(true); // Parse error... :(
}
@ -241,17 +263,20 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
}
case BytecodeFormat::SymbolTable:
if (ParseSymbolTable(Buf, Buf+Size)) {
cerr << "Error reading method symbol table!\n";
BCR_TRACE(2, "BLOCK BytecodeFormat::SymbolTable: {\n");
if (ParseSymbolTable(Buf, Buf+Size, M->getSymbolTableSure())) {
delete M; return failure(true);
}
break;
default:
BCR_TRACE(2, "BLOCK <unknown>:ignored! {\n");
Buf += Size;
if (OldBuf > Buf) return failure(true); // Wrap around!
break;
}
BCR_TRACE(2, "} end block\n");
if (align32(Buf, EndBuf)) {
delete M; // Malformed bc file, read past end of block.
return failure(true);
@ -298,15 +323,15 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
while (MethSignature != Type::VoidTyID) { // List is terminated by Void
const Type *Ty = getType(MethSignature);
if (!Ty || !Ty->isMethodType()) {
cerr << "Method not meth type! ";
cerr << "Method not meth type! Ty = " << Ty << endl;
if (Ty) cerr << Ty->getName(); else cerr << MethSignature; cerr << endl;
return failure(true);
}
// When the ModuleGlobalInfo section is read, we load the type of each method
// and the 'ModuleValues' slot that it lands in. We then load a placeholder
// into its slot to reserve it. When the method is loaded, this placeholder
// is replaced.
// When the ModuleGlobalInfo section is read, we load the type of each
// method and the 'ModuleValues' slot that it lands in. We then load a
// placeholder into its slot to reserve it. When the method is loaded, this
// placeholder is replaced.
// Insert the placeholder...
Value *Def = new MethPHolder(Ty, 0);
@ -323,6 +348,7 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
//
MethodSignatureList.push_back(make_pair((const MethodType*)Ty, SlotNo));
if (read_vbr(Buf, End, MethSignature)) return failure(true);
BCR_TRACE(2, "Method of type: " << Ty << endl);
}
if (align32(Buf, End)) return failure(true);
@ -342,33 +368,36 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
if (Type != BytecodeFormat::Module || Buf+Size != EndBuf)
return failure(true); // Hrm, not a class?
BCR_TRACE(0, "BLOCK BytecodeFormat::Module: {\n");
MethodSignatureList.clear(); // Just in case...
// Read into instance variables...
if (read_vbr(Buf, EndBuf, FirstDerivedTyID)) return failure(true);
if (align32(Buf, EndBuf)) return failure(true);
BCR_TRACE(1, "FirstDerivedTyID = " << FirstDerivedTyID << "\n");
C = new Module();
while (Buf < EndBuf) {
const uchar *OldBuf = Buf;
if (readBlock(Buf, EndBuf, Type, Size)) { delete C; return failure(true); }
switch (Type) {
case BytecodeFormat::ModuleGlobalInfo:
if (ParseModuleGlobalInfo(Buf, Buf+Size, C)) {
cerr << "Error reading class global info section!\n";
case BytecodeFormat::ConstantPool:
BCR_TRACE(1, "BLOCK BytecodeFormat::ConstantPool: {\n");
if (ParseConstantPool(Buf, Buf+Size, ModuleValues, ModuleTypeValues)) {
delete C; return failure(true);
}
break;
case BytecodeFormat::ConstantPool:
if (ParseConstantPool(Buf, Buf+Size, C->getConstantPool(), ModuleValues)) {
cerr << "Error reading class constant pool!\n";
case BytecodeFormat::ModuleGlobalInfo:
BCR_TRACE(1, "BLOCK BytecodeFormat::ModuleGlobalInfo: {\n");
if (ParseModuleGlobalInfo(Buf, Buf+Size, C)) {
delete C; return failure(true);
}
break;
case BytecodeFormat::Method: {
BCR_TRACE(1, "BLOCK BytecodeFormat::Method: {\n");
if (ParseMethod(Buf, Buf+Size, C)) {
delete C; return failure(true); // Error parsing method
}
@ -376,23 +405,26 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
}
case BytecodeFormat::SymbolTable:
if (ParseSymbolTable(Buf, Buf+Size)) {
cerr << "Error reading class symbol table!\n";
BCR_TRACE(1, "BLOCK BytecodeFormat::SymbolTable: {\n");
if (ParseSymbolTable(Buf, Buf+Size, C->getSymbolTableSure())) {
delete C; return failure(true);
}
break;
default:
cerr << "Unknown class block: " << Type << endl;
cerr << " Unknown class block: " << Type << endl;
Buf += Size;
if (OldBuf > Buf) return failure(true); // Wrap around!
break;
}
BCR_TRACE(1, "} end block\n");
if (align32(Buf, EndBuf)) { delete C; return failure(true); }
}
if (!MethodSignatureList.empty()) // Expected more methods!
return failure(true);
BCR_TRACE(0, "} end block\n\n");
return false;
}

39
lib/Bytecode/Reader/ReaderInternals.h
View File

@ -14,6 +14,16 @@
#include <map>
#include <utility>
// 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 << string(n*2, ' ') << X
#else
#define BCR_TRACE(n, X)
#endif
class BasicBlock;
class Method;
class Module;
@ -32,7 +42,7 @@ struct RawInst { // The raw fields out of the bytecode stream...
};
};
class BytecodeParser {
class BytecodeParser : public AbstractTypeUser {
public:
BytecodeParser() {
// Define this in case we don't see a ModuleGlobalInfo block.
@ -43,10 +53,15 @@ public:
private: // All of this data is transient across calls to ParseBytecode
typedef vector<Value *> ValueList;
typedef vector<ValueList> ValueTable;
typedef map<const Type *, unsigned> TypeMapType;
ValueTable Values, LateResolveValues;
ValueTable ModuleValues, LateResolveModuleValues;
TypeMapType TypeMap;
// TypesLoaded - This vector mirrors the Values[TypeTyID] plane. It is used
// to deal with forward references to types.
//
typedef vector<PATypeHandle<Type> > TypeValuesListTy;
TypeValuesListTy ModuleTypeValues;
TypeValuesListTy MethodTypeValues;
// Information read from the ModuleGlobalInfo section of the file...
unsigned FirstDerivedTyID;
@ -61,19 +76,19 @@ private: // All of this data is transient across calls to ParseBytecode
private:
bool ParseModule (const uchar * Buf, const uchar *End, Module *&);
bool ParseModuleGlobalInfo (const uchar *&Buf, const uchar *End, Module *);
bool ParseSymbolTable (const uchar *&Buf, const uchar *End);
bool ParseMethod (const uchar *&Buf, const uchar *End, Module *);
bool ParseSymbolTable (const uchar *&Buf, const uchar *End, SymbolTable *);
bool ParseMethod (const uchar *&Buf, const uchar *End, Module *);
bool ParseBasicBlock (const uchar *&Buf, const uchar *End, BasicBlock *&);
bool ParseInstruction (const uchar *&Buf, const uchar *End, Instruction *&);
bool ParseRawInst (const uchar *&Buf, const uchar *End, RawInst &);
bool ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
SymTabValue::ConstantPoolType &CP, ValueTable &Tab);
ValueTable &Tab, TypeValuesListTy &TypeTab);
bool parseConstPoolValue(const uchar *&Buf, const uchar *End,
const Type *Ty, ConstPoolVal *&V);
bool parseTypeConstant (const uchar *&Buf, const uchar *, ConstPoolVal *&);
bool parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
TypeValuesListTy &Tab, unsigned NumEntries);
const Type *parseTypeConstant(const uchar *&Buf, const uchar *EndBuf);
Value *getValue(const Type *Ty, unsigned num, bool Create = true);
const Type *getType(unsigned ID);
@ -82,6 +97,12 @@ private:
bool postResolveValues(ValueTable &ValTab);
bool getTypeSlot(const Type *Ty, unsigned &Slot);
// refineAbstractType - The callback method is invoked when one of the
// elements of TypeValues becomes more concrete...
//
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
};
template<class SuperType>