-//===- ReadConst.cpp - Code to constants and constant pools -----------------===
+//===- ReadConst.cpp - Code to constants and constant pools ---------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This file implements functionality to deserialize constants and entire
// constant pools.
//
// Note that this library should be as fast as possible, reentrant, and
-// threadsafe!!
+// thread-safe!!
//
-//===------------------------------------------------------------------------===
+//===----------------------------------------------------------------------===//
-#include "llvm/Module.h"
-#include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
-#include "llvm/DerivedTypes.h"
#include "ReaderInternals.h"
+#include "llvm/Module.h"
+#include "llvm/Constants.h"
#include <algorithm>
+using namespace llvm;
-
-
-const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
- const uchar *EndBuf) {
+const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
+ const unsigned char *EndBuf) {
unsigned PrimType;
- if (read_vbr(Buf, EndBuf, PrimType)) return failure<const Type*>(0);
+ if (read_vbr(Buf, EndBuf, PrimType)) throw Error_readvbr;
const Type *Val = 0;
if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
return Val;
switch (PrimType) {
- case Type::MethodTyID: {
+ case Type::FunctionTyID: {
unsigned Typ;
- if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
+ if (read_vbr(Buf, EndBuf, Typ)) return Val;
const Type *RetType = getType(Typ);
- if (RetType == 0) return failure(Val);
unsigned NumParams;
- if (read_vbr(Buf, EndBuf, NumParams)) return failure(Val);
+ if (read_vbr(Buf, EndBuf, NumParams)) return Val;
- vector<const Type*> Params;
+ std::vector<const Type*> Params;
while (NumParams--) {
- if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
- const Type *Ty = getType(Typ);
- if (Ty == 0) return failure(Val);
- Params.push_back(Ty);
+ if (read_vbr(Buf, EndBuf, Typ)) return Val;
+ Params.push_back(getType(Typ));
}
- Val = MethodType::get(RetType, Params);
- break;
+ bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+ if (isVarArg) Params.pop_back();
+
+ return FunctionType::get(RetType, Params, isVarArg);
}
case Type::ArrayTyID: {
unsigned ElTyp;
- if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
+ if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
const Type *ElementType = getType(ElTyp);
- if (ElementType == 0) return failure(Val);
- int NumElements;
- if (read_vbr(Buf, EndBuf, NumElements)) return failure(Val);
- Val = ArrayType::get(ElementType, NumElements);
- break;
+ unsigned NumElements;
+ if (read_vbr(Buf, EndBuf, NumElements)) return Val;
+
+ BCR_TRACE(5, "Array Type Constant #" << ElTyp << " size="
+ << NumElements << "\n");
+ return ArrayType::get(ElementType, NumElements);
}
case Type::StructTyID: {
unsigned Typ;
- vector<const Type*> Elements;
+ std::vector<const Type*> Elements;
- if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
+ if (read_vbr(Buf, EndBuf, Typ)) return Val;
while (Typ) { // List is terminated by void/0 typeid
- const Type *Ty = getType(Typ);
- if (Ty == 0) return failure(Val);
- Elements.push_back(Ty);
-
- if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
+ Elements.push_back(getType(Typ));
+ if (read_vbr(Buf, EndBuf, Typ)) return Val;
}
- Val = StructType::get(Elements);
- break;
+ return StructType::get(Elements);
}
case Type::PointerTyID: {
unsigned ElTyp;
- if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
- const Type *ElementType = getType(ElTyp);
- if (ElementType == 0) return failure(Val);
- Val = PointerType::get(ElementType);
- break;
+ if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
+ BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
+ return PointerType::get(getType(ElTyp));
}
- default:
- cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to deserialize"
- << " primitive Type " << PrimType << "\n";
- return failure(Val);
+ case Type::OpaqueTyID: {
+ return OpaqueType::get();
}
- 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!");
+ default:
+ std::cerr << __FILE__ << ":" << __LINE__
+ << ": Don't know how to deserialize"
+ << " primitive Type " << PrimType << "\n";
+ return Val;
}
-
- *I = NewType; // Update to point to new, more refined type.
}
-
-
-// parseTypeConstants - We have to use this wierd code to handle recursive
+// parseTypeConstants - We have to use this weird 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
+// this ugly problem, we pessimistically 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,
+namespace llvm { void debug_type_tables(); }
+void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
+ const unsigned char *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();
+ assert(Tab.size() == 0 && "should not have read type constants in before!");
// 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));
+ // FIXME: this is dumb
+ Tab.reserve(NumEntries);
+ for (unsigned i = 0; i < NumEntries; ++i)
+ Tab.push_back(OpaqueType::get());
// 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");
+ for (unsigned i = 0; i < NumEntries; ++i) {
+ const Type *NewTy = parseTypeConstant(Buf, EndBuf), *OldTy = Tab[i].get();
+ if (NewTy == 0) throw std::string("Parsed invalid type.");
+ BCR_TRACE(4, "#" << i << ": Read Type Constant: '" << NewTy <<
+ "' Replacing: " << OldTy << "\n");
// Don't insertValue the new type... instead we want to replace the opaque
// type with the new concrete value...
// abstract type to use the newty. This also will cause the opaque type
// to be deleted...
//
- cast<DerivedType>(Tab[i+BaseLevel].get())->refineAbstractTypeTo(NewTy);
+ ((DerivedType*)Tab[i].get())->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!");
+ // value table... or with a preexisting type that was already in the system
+ assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
}
BCR_TRACE(5, "Resulting types:\n");
- for (unsigned i = 0; i < NumEntries; i++) {
- BCR_TRACE(5, cast<const Type>(Tab[i+BaseLevel]) << "\n");
+ for (unsigned i = 0; i < NumEntries; ++i) {
+ BCR_TRACE(5, (void*)Tab[i].get() << " - " << Tab[i].get() << "\n");
}
- return false;
+ debug_type_tables();
}
-bool BytecodeParser::parseConstPoolValue(const uchar *&Buf,
- const uchar *EndBuf,
- const Type *Ty, ConstPoolVal *&V) {
+Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
+ const unsigned char *EndBuf,
+ unsigned TypeID) {
+
+ // We must check for a ConstantExpr before switching by type because
+ // a ConstantExpr can be of any type, and has no explicit value.
+ //
+ unsigned isExprNumArgs; // 0 if not expr; numArgs if is expr
+ if (read_vbr(Buf, EndBuf, isExprNumArgs)) throw Error_readvbr;
+ if (isExprNumArgs) {
+ // FIXME: Encoding of constant exprs could be much more compact!
+ unsigned Opcode;
+ std::vector<Constant*> ArgVec;
+ ArgVec.reserve(isExprNumArgs);
+ if (read_vbr(Buf, EndBuf, Opcode)) throw Error_readvbr;
+
+ // Read the slot number and types of each of the arguments
+ for (unsigned i = 0; i != isExprNumArgs; ++i) {
+ unsigned ArgValSlot, ArgTypeSlot;
+ if (read_vbr(Buf, EndBuf, ArgValSlot)) throw Error_readvbr;
+ if (read_vbr(Buf, EndBuf, ArgTypeSlot)) throw Error_readvbr;
+ BCR_TRACE(4, "CE Arg " << i << ": Type: '" << *getType(ArgTypeSlot)
+ << "' slot: " << ArgValSlot << "\n");
+
+ // Get the arg value from its slot if it exists, otherwise a placeholder
+ ArgVec.push_back(getConstantValue(ArgTypeSlot, ArgValSlot));
+ }
+
+ // Construct a ConstantExpr of the appropriate kind
+ if (isExprNumArgs == 1) { // All one-operand expressions
+ assert(Opcode == Instruction::Cast);
+ return ConstantExpr::getCast(ArgVec[0], getType(TypeID));
+ } else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
+ std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
+ return ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
+ } else if (Opcode == Instruction::Shl || Opcode == Instruction::Shr) {
+ return ConstantExpr::getShift(Opcode, ArgVec[0], ArgVec[1]);
+ } else { // All other 2-operand expressions
+ return ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
+ }
+ }
+
+ // Ok, not an ConstantExpr. We now know how to read the given type...
+ const Type *Ty = getType(TypeID);
switch (Ty->getPrimitiveID()) {
case Type::BoolTyID: {
unsigned Val;
- if (read_vbr(Buf, EndBuf, Val)) return failure(true);
- if (Val != 0 && Val != 1) return failure(true);
- V = ConstPoolBool::get(Val == 1);
- break;
+ if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
+ if (Val != 0 && Val != 1) throw std::string("Invalid boolean value read.");
+ return ConstantBool::get(Val == 1);
}
case Type::UByteTyID: // Unsigned integer types...
case Type::UShortTyID:
case Type::UIntTyID: {
unsigned Val;
- if (read_vbr(Buf, EndBuf, Val)) return failure(true);
- if (!ConstPoolUInt::isValueValidForType(Ty, Val)) return failure(true);
- V = ConstPoolUInt::get(Ty, Val);
- break;
+ if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
+ if (!ConstantUInt::isValueValidForType(Ty, Val))
+ throw std::string("Invalid unsigned byte/short/int read.");
+ return ConstantUInt::get(Ty, Val);
}
case Type::ULongTyID: {
uint64_t Val;
- if (read_vbr(Buf, EndBuf, Val)) return failure(true);
- V = ConstPoolUInt::get(Ty, Val);
- break;
+ if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
+ return ConstantUInt::get(Ty, Val);
}
- case Type::SByteTyID: // Unsigned integer types...
+ case Type::SByteTyID: // Signed integer types...
case Type::ShortTyID:
case Type::IntTyID: {
- int Val;
- if (read_vbr(Buf, EndBuf, Val)) return failure(true);
- if (!ConstPoolSInt::isValueValidForType(Ty, Val)) return failure(true);
- V = ConstPoolSInt::get(Ty, Val);
- break;
- }
-
- case Type::LongTyID: {
+ case Type::LongTyID:
int64_t Val;
- if (read_vbr(Buf, EndBuf, Val)) return failure(true);
- V = ConstPoolSInt::get(Ty, Val);
- break;
+ if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
+ if (!ConstantSInt::isValueValidForType(Ty, Val))
+ throw std::string("Invalid signed byte/short/int/long read.");
+ return ConstantSInt::get(Ty, Val);
}
case Type::FloatTyID: {
float F;
- if (input_data(Buf, EndBuf, &F, &F+1)) return failure(true);
- V = ConstPoolFP::get(Ty, F);
- break;
+ if (input_data(Buf, EndBuf, &F, &F+1)) throw Error_inputdata;
+ return ConstantFP::get(Ty, F);
}
case Type::DoubleTyID: {
double Val;
- if (input_data(Buf, EndBuf, &Val, &Val+1)) return failure(true);
- V = ConstPoolFP::get(Ty, Val);
- break;
+ if (input_data(Buf, EndBuf, &Val, &Val+1)) throw Error_inputdata;
+ return ConstantFP::get(Ty, Val);
}
case Type::TypeTyID:
- assert(0 && "Type constants should be handled seperately!!!");
- abort();
+ throw std::string("Type constants shouldn't live in constant table!");
case Type::ArrayTyID: {
- const ArrayType *AT = cast<const ArrayType>(Ty);
- unsigned NumElements;
- if (AT->isSized()) // Sized array, # elements stored in type!
- NumElements = (unsigned)AT->getNumElements();
- else // Unsized array, # elements stored in stream!
- if (read_vbr(Buf, EndBuf, NumElements)) return failure(true);
-
- vector<ConstPoolVal *> Elements;
+ const ArrayType *AT = cast<ArrayType>(Ty);
+ unsigned NumElements = AT->getNumElements();
+ unsigned TypeSlot = getTypeSlot(AT->getElementType());
+ std::vector<Constant*> Elements;
while (NumElements--) { // Read all of the elements of the constant.
unsigned Slot;
- if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
- Value *V = getValue(AT->getElementType(), Slot, false);
- if (!V || !isa<ConstPoolVal>(V)) return failure(true);
- Elements.push_back(cast<ConstPoolVal>(V));
+ if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
+ Elements.push_back(getConstantValue(TypeSlot, Slot));
}
- V = ConstPoolArray::get(AT, Elements);
- break;
+ return ConstantArray::get(AT, Elements);
}
case Type::StructTyID: {
const StructType *ST = cast<StructType>(Ty);
const StructType::ElementTypes &ET = ST->getElementTypes();
- vector<ConstPoolVal *> Elements;
+ std::vector<Constant *> Elements;
for (unsigned i = 0; i < ET.size(); ++i) {
unsigned Slot;
- if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
- Value *V = getValue(ET[i], Slot, false);
- if (!V || !isa<ConstPoolVal>(V))
- return failure(true);
- Elements.push_back(cast<ConstPoolVal>(V));
+ if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
+ Elements.push_back(getConstantValue(ET[i], Slot));
}
- V = ConstPoolStruct::get(ST, Elements);
- break;
+ return ConstantStruct::get(ST, Elements);
}
- case Type::PointerTyID: {
- const PointerType *PT = cast<const PointerType>(Ty);
- unsigned SubClass;
- if (read_vbr(Buf, EndBuf, SubClass)) return failure(true);
- if (SubClass != 0) return failure(true);
-
-
- V = ConstPoolPointer::getNullPointer(PT);
- break;
+ case Type::PointerTyID: { // ConstantPointerRef value...
+ const PointerType *PT = cast<PointerType>(Ty);
+ unsigned Slot;
+ if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
+ BCR_TRACE(4, "CPR: Type: '" << Ty << "' slot: " << Slot << "\n");
+
+ // Check to see if we have already read this global variable...
+ Value *Val = getValue(TypeID, Slot, false);
+ GlobalValue *GV;
+ if (Val) {
+ if (!(GV = dyn_cast<GlobalValue>(Val)))
+ throw std::string("Value of ConstantPointerRef not in ValueTable!");
+ BCR_TRACE(5, "Value Found in ValueTable!\n");
+ } else {
+ throw std::string("Forward references are not allowed here.");
+ }
+
+ return ConstantPointerRef::get(GV);
}
default:
- cerr << __FILE__ << ":" << __LINE__
- << ": Don't know how to deserialize constant value of type '"
- << Ty->getName() << "'\n";
- return failure(true);
+ throw std::string("Don't know how to deserialize constant value of type '"+
+ Ty->getDescription());
}
+}
- return false;
+void BytecodeParser::ParseGlobalTypes(const unsigned char *&Buf,
+ const unsigned char *EndBuf) {
+ ValueTable T;
+ ParseConstantPool(Buf, EndBuf, T, ModuleTypeValues);
}
-bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
- ValueTable &Tab,
- TypeValuesListTy &TypeTab) {
+void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
+ const unsigned char *EndBuf,
+ ValueTable &Tab,
+ TypeValuesListTy &TypeTab) {
while (Buf < EndBuf) {
unsigned NumEntries, Typ;
if (read_vbr(Buf, EndBuf, NumEntries) ||
- 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");
-
+ read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
if (Typ == Type::TypeTyID) {
- if (parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries)) return true;
+ BCR_TRACE(3, "Type: 'type' NumEntries: " << NumEntries << "\n");
+ parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
} 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);
+ BCR_TRACE(3, "Type: '" << *getType(Typ) << "' NumEntries: "
+ << NumEntries << "\n");
+
+ for (unsigned i = 0; i < NumEntries; ++i) {
+ Constant *C = parseConstantValue(Buf, EndBuf, Typ);
+ assert(C && "parseConstantValue returned NULL!");
+ BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
+ unsigned Slot = insertValue(C, Typ, Tab);
+
+ // If we are reading a function constant table, make sure that we adjust
+ // the slot number to be the real global constant number.
+ //
+ if (&Tab != &ModuleValues && Typ < ModuleValues.size())
+ Slot += ModuleValues[Typ]->size();
+ ResolveReferencesToConstant(C, Slot);
}
}
}
- if (Buf > EndBuf) return failure(true);
- return false;
+ if (Buf > EndBuf) throw std::string("Read past end of buffer.");
}
projects / oota-llvm.git / blobdiff