2001-12-03 23:26:30 +01:00
|
|
|
//===- ReadConst.cpp - Code to constants and constant pools ---------------===//
|
2001-06-06 22:29:01 +02:00
|
|
|
//
|
|
|
|
// This file implements functionality to deserialize constants and entire
|
|
|
|
// constant pools.
|
|
|
|
//
|
|
|
|
// Note that this library should be as fast as possible, reentrant, and
|
|
|
|
// threadsafe!!
|
|
|
|
//
|
2001-12-03 23:26:30 +01:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-12-03 19:02:31 +01:00
|
|
|
#include "ReaderInternals.h"
|
2001-06-06 22:29:01 +02:00
|
|
|
#include "llvm/Module.h"
|
2002-04-28 21:55:58 +02:00
|
|
|
#include "llvm/Constants.h"
|
2001-10-13 08:47:01 +02:00
|
|
|
#include "llvm/GlobalVariable.h"
|
2001-09-07 18:37:43 +02:00
|
|
|
#include <algorithm>
|
2002-01-20 23:54:45 +01:00
|
|
|
#include <iostream>
|
2002-06-25 22:44:04 +02:00
|
|
|
|
2002-01-20 23:54:45 +01:00
|
|
|
using std::make_pair;
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
|
|
|
|
const uchar *EndBuf) {
|
2001-06-06 22:29:01 +02:00
|
|
|
unsigned PrimType;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, PrimType)) return failure<const Type*>(0);
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
const Type *Val = 0;
|
|
|
|
if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
|
|
|
|
return Val;
|
2001-06-06 22:29:01 +02:00
|
|
|
|
|
|
|
switch (PrimType) {
|
2002-03-29 04:51:11 +01:00
|
|
|
case Type::FunctionTyID: {
|
2001-06-06 22:29:01 +02:00
|
|
|
unsigned Typ;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
const Type *RetType = getType(Typ);
|
2001-09-07 18:37:43 +02:00
|
|
|
if (RetType == 0) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-07-26 00:47:55 +02:00
|
|
|
unsigned NumParams;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, NumParams)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2002-01-20 23:54:45 +01:00
|
|
|
std::vector<const Type*> Params;
|
2001-07-26 00:47:55 +02:00
|
|
|
while (NumParams--) {
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
const Type *Ty = getType(Typ);
|
2001-09-07 18:37:43 +02:00
|
|
|
if (Ty == 0) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
Params.push_back(Ty);
|
|
|
|
}
|
|
|
|
|
2001-10-13 08:47:01 +02:00
|
|
|
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
|
|
|
|
if (isVarArg) Params.pop_back();
|
|
|
|
|
2002-03-29 04:51:11 +01:00
|
|
|
return FunctionType::get(RetType, Params, isVarArg);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
case Type::ArrayTyID: {
|
|
|
|
unsigned ElTyp;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
const Type *ElementType = getType(ElTyp);
|
2001-09-07 18:37:43 +02:00
|
|
|
if (ElementType == 0) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-12-14 17:30:51 +01:00
|
|
|
unsigned NumElements;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, NumElements)) return failure(Val);
|
2001-10-24 08:21:22 +02:00
|
|
|
|
|
|
|
BCR_TRACE(5, "Array Type Constant #" << ElTyp << " size="
|
2002-01-20 23:54:45 +01:00
|
|
|
<< NumElements << "\n");
|
2001-10-24 08:21:22 +02:00
|
|
|
return ArrayType::get(ElementType, NumElements);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
case Type::StructTyID: {
|
|
|
|
unsigned Typ;
|
2002-01-20 23:54:45 +01:00
|
|
|
std::vector<const Type*> Elements;
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
while (Typ) { // List is terminated by void/0 typeid
|
|
|
|
const Type *Ty = getType(Typ);
|
2001-09-07 18:37:43 +02:00
|
|
|
if (Ty == 0) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
Elements.push_back(Ty);
|
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
|
2001-10-24 08:21:22 +02:00
|
|
|
return StructType::get(Elements);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
case Type::PointerTyID: {
|
|
|
|
unsigned ElTyp;
|
2001-09-07 18:37:43 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, ElTyp)) return failure(Val);
|
2002-01-20 23:54:45 +01:00
|
|
|
BCR_TRACE(5, "Pointer Type Constant #" << (ElTyp-14) << "\n");
|
2001-06-06 22:29:01 +02:00
|
|
|
const Type *ElementType = getType(ElTyp);
|
2001-09-07 18:37:43 +02:00
|
|
|
if (ElementType == 0) return failure(Val);
|
2001-10-24 08:21:22 +02:00
|
|
|
return PointerType::get(ElementType);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
|
2001-10-23 03:53:01 +02:00
|
|
|
case Type::OpaqueTyID: {
|
2001-10-24 08:21:22 +02:00
|
|
|
return OpaqueType::get();
|
2001-10-23 03:53:01 +02:00
|
|
|
}
|
|
|
|
|
2001-06-06 22:29:01 +02:00
|
|
|
default:
|
2002-06-25 22:44:04 +02:00
|
|
|
std::cerr << __FILE__ << ":" << __LINE__
|
2002-06-30 18:04:37 +02:00
|
|
|
<< ": Don't know how to deserialize"
|
|
|
|
<< " primitive Type " << PrimType << "\n";
|
2001-09-07 18:37:43 +02:00
|
|
|
return failure(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) {
|
2001-11-03 04:27:53 +01:00
|
|
|
if (OldType == NewType &&
|
|
|
|
OldType->isAbstract()) return; // Type is modified, but same
|
2001-10-13 08:47:01 +02:00
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
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!");
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
|
2001-11-03 04:27:53 +01:00
|
|
|
if (OldType == NewType) {
|
|
|
|
assert(!OldType->isAbstract());
|
|
|
|
I->removeUserFromConcrete();
|
|
|
|
} else {
|
|
|
|
*I = NewType; // Update to point to new, more refined type.
|
|
|
|
}
|
2001-09-07 18:37:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 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.
|
|
|
|
//
|
2002-04-07 08:11:22 +02:00
|
|
|
void debug_type_tables();
|
2001-09-07 18:37:43 +02:00
|
|
|
bool BytecodeParser::parseTypeConstants(const uchar *&Buf, const uchar *EndBuf,
|
|
|
|
TypeValuesListTy &Tab,
|
|
|
|
unsigned NumEntries) {
|
2001-10-13 08:47:01 +02:00
|
|
|
assert(Tab.size() == 0 && "should not have read type constants in before!");
|
2001-09-07 18:37:43 +02:00
|
|
|
|
|
|
|
// Insert a bunch of opaque types to be resolved later...
|
2001-10-24 08:21:22 +02:00
|
|
|
for (unsigned i = 0; i < NumEntries; ++i)
|
2001-09-07 18:37:43 +02:00
|
|
|
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.
|
|
|
|
//
|
2001-10-24 08:21:22 +02:00
|
|
|
for (unsigned i = 0; i < NumEntries; ++i) {
|
2001-10-13 08:47:01 +02:00
|
|
|
const Type *NewTy = parseTypeConstant(Buf, EndBuf), *OldTy = Tab[i].get();
|
2001-09-07 18:37:43 +02:00
|
|
|
if (NewTy == 0) return failure(true);
|
2001-10-24 08:21:22 +02:00
|
|
|
BCR_TRACE(4, "#" << i << ": Read Type Constant: '" << NewTy <<
|
|
|
|
"' Replacing: " << OldTy << "\n");
|
2001-09-07 18:37:43 +02:00
|
|
|
|
|
|
|
// 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...
|
|
|
|
//
|
2002-06-05 19:38:28 +02:00
|
|
|
((DerivedType*)Tab[i].get())->refineAbstractTypeTo(NewTy);
|
2001-09-07 18:37:43 +02:00
|
|
|
|
|
|
|
// This should have replace the old opaque type with the new type in the
|
2001-10-13 08:47:01 +02:00
|
|
|
// value table... or with a preexisting type that was already in the system
|
|
|
|
assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
|
2001-09-07 18:37:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
BCR_TRACE(5, "Resulting types:\n");
|
2001-10-24 08:21:22 +02:00
|
|
|
for (unsigned i = 0; i < NumEntries; ++i) {
|
2002-04-07 08:11:22 +02:00
|
|
|
BCR_TRACE(5, (void*)Tab[i].get() << " - " << Tab[i].get() << "\n");
|
2001-09-07 18:37:43 +02:00
|
|
|
}
|
2002-04-07 08:11:22 +02:00
|
|
|
debug_type_tables();
|
2001-06-06 22:29:01 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
|
2001-12-03 23:26:30 +01:00
|
|
|
bool BytecodeParser::parseConstantValue(const uchar *&Buf, const uchar *EndBuf,
|
|
|
|
const Type *Ty, Constant *&V) {
|
2002-07-15 01:05:09 +02:00
|
|
|
|
|
|
|
// 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)) return failure(true);
|
|
|
|
if (isExprNumArgs) {
|
2002-07-30 20:54:22 +02:00
|
|
|
// 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)) return failure(true);
|
|
|
|
|
2002-07-15 01:05:09 +02:00
|
|
|
// Read the slot number and types of each of the arguments
|
2002-07-30 20:54:22 +02:00
|
|
|
for (unsigned i = 0; i != isExprNumArgs; ++i) {
|
|
|
|
unsigned ArgValSlot, ArgTypeSlot;
|
|
|
|
if (read_vbr(Buf, EndBuf, ArgValSlot)) return failure(true);
|
|
|
|
if (read_vbr(Buf, EndBuf, ArgTypeSlot)) return failure(true);
|
|
|
|
const Type *ArgTy = getType(ArgTypeSlot);
|
|
|
|
if (ArgTy == 0) return failure(true);
|
2002-07-15 01:05:09 +02:00
|
|
|
|
2002-07-30 20:54:22 +02:00
|
|
|
BCR_TRACE(4, "CE Arg " << i << ": Type: '" << ArgTy << "' slot: "
|
|
|
|
<< ArgValSlot << "\n");
|
2002-07-15 01:05:09 +02:00
|
|
|
|
|
|
|
// Get the arg value from its slot if it exists, otherwise a placeholder
|
2002-07-30 20:54:22 +02:00
|
|
|
Value *Val = getValue(ArgTy, ArgValSlot, false);
|
2002-07-18 02:14:27 +02:00
|
|
|
Constant *C;
|
2002-07-15 01:05:09 +02:00
|
|
|
if (Val) {
|
|
|
|
if (!(C = dyn_cast<Constant>(Val))) return failure(true);
|
|
|
|
BCR_TRACE(5, "Constant Found in ValueTable!\n");
|
|
|
|
} else { // Nope... find or create a forward ref. for it
|
2002-07-30 20:54:22 +02:00
|
|
|
C = fwdRefs.GetFwdRefToConstant(ArgTy, ArgValSlot);
|
2002-07-15 01:05:09 +02:00
|
|
|
}
|
2002-07-30 20:54:22 +02:00
|
|
|
ArgVec.push_back(C);
|
2002-07-15 01:05:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Construct a ConstantExpr of the appropriate kind
|
|
|
|
if (isExprNumArgs == 1) { // All one-operand expressions
|
2002-07-30 20:54:22 +02:00
|
|
|
V = ConstantExpr::get(Opcode, ArgVec[0], Ty);
|
|
|
|
} else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
|
|
|
|
std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
|
|
|
|
V = ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
|
2002-07-15 01:05:09 +02:00
|
|
|
} else { // All other 2-operand expressions
|
2002-07-30 20:54:22 +02:00
|
|
|
V = ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
|
2002-07-15 01:05:09 +02:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ok, not an ConstantExpr. We now know how to read the given type...
|
2001-06-06 22:29:01 +02:00
|
|
|
switch (Ty->getPrimitiveID()) {
|
|
|
|
case Type::BoolTyID: {
|
|
|
|
unsigned Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
|
|
|
|
if (Val != 0 && Val != 1) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantBool::get(Val == 1);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::UByteTyID: // Unsigned integer types...
|
|
|
|
case Type::UShortTyID:
|
|
|
|
case Type::UIntTyID: {
|
|
|
|
unsigned Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
if (!ConstantUInt::isValueValidForType(Ty, Val)) return failure(true);
|
|
|
|
V = ConstantUInt::get(Ty, Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::ULongTyID: {
|
|
|
|
uint64_t Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantUInt::get(Ty, Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::SByteTyID: // Unsigned integer types...
|
|
|
|
case Type::ShortTyID:
|
|
|
|
case Type::IntTyID: {
|
|
|
|
int Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
if (!ConstantSInt::isValueValidForType(Ty, Val)) return failure(true);
|
|
|
|
V = ConstantSInt::get(Ty, Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::LongTyID: {
|
|
|
|
int64_t Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Val)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantSInt::get(Ty, Val);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-07-15 02:17:18 +02:00
|
|
|
case Type::FloatTyID: {
|
|
|
|
float F;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (input_data(Buf, EndBuf, &F, &F+1)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantFP::get(Ty, F);
|
2001-07-15 02:17:18 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::DoubleTyID: {
|
|
|
|
double Val;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (input_data(Buf, EndBuf, &Val, &Val+1)) return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantFP::get(Ty, Val);
|
2001-07-15 02:17:18 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-06-06 22:29:01 +02:00
|
|
|
case Type::TypeTyID:
|
2001-09-07 18:37:43 +02:00
|
|
|
assert(0 && "Type constants should be handled seperately!!!");
|
|
|
|
abort();
|
2001-06-06 22:29:01 +02:00
|
|
|
|
|
|
|
case Type::ArrayTyID: {
|
2001-10-02 05:41:24 +02:00
|
|
|
const ArrayType *AT = cast<const ArrayType>(Ty);
|
2001-12-14 17:30:51 +01:00
|
|
|
unsigned NumElements = AT->getNumElements();
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2002-01-20 23:54:45 +01:00
|
|
|
std::vector<Constant*> Elements;
|
2001-06-06 22:29:01 +02:00
|
|
|
while (NumElements--) { // Read all of the elements of the constant.
|
|
|
|
unsigned Slot;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
|
2001-06-06 22:29:01 +02:00
|
|
|
Value *V = getValue(AT->getElementType(), Slot, false);
|
2001-12-03 23:26:30 +01:00
|
|
|
if (!V || !isa<Constant>(V)) return failure(true);
|
|
|
|
Elements.push_back(cast<Constant>(V));
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantArray::get(AT, Elements);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Type::StructTyID: {
|
2001-10-02 05:41:24 +02:00
|
|
|
const StructType *ST = cast<StructType>(Ty);
|
2001-06-06 22:29:01 +02:00
|
|
|
const StructType::ElementTypes &ET = ST->getElementTypes();
|
|
|
|
|
2002-01-20 23:54:45 +01:00
|
|
|
std::vector<Constant *> Elements;
|
2001-06-06 22:29:01 +02:00
|
|
|
for (unsigned i = 0; i < ET.size(); ++i) {
|
|
|
|
unsigned Slot;
|
2001-07-28 19:50:18 +02:00
|
|
|
if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
|
2001-06-06 22:29:01 +02:00
|
|
|
Value *V = getValue(ET[i], Slot, false);
|
2001-12-03 23:26:30 +01:00
|
|
|
if (!V || !isa<Constant>(V))
|
2001-07-28 19:50:18 +02:00
|
|
|
return failure(true);
|
2001-12-03 23:26:30 +01:00
|
|
|
Elements.push_back(cast<Constant>(V));
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantStruct::get(ST, Elements);
|
2001-06-06 22:29:01 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-10-01 00:46:54 +02:00
|
|
|
case Type::PointerTyID: {
|
2001-10-02 05:41:24 +02:00
|
|
|
const PointerType *PT = cast<const PointerType>(Ty);
|
2001-10-01 00:46:54 +02:00
|
|
|
unsigned SubClass;
|
|
|
|
if (read_vbr(Buf, EndBuf, SubClass)) return failure(true);
|
2001-10-13 08:47:01 +02:00
|
|
|
switch (SubClass) {
|
2001-12-03 23:26:30 +01:00
|
|
|
case 0: // ConstantPointerNull value...
|
|
|
|
V = ConstantPointerNull::get(PT);
|
2001-10-13 08:47:01 +02:00
|
|
|
break;
|
2001-10-01 00:46:54 +02:00
|
|
|
|
2001-12-03 23:26:30 +01:00
|
|
|
case 1: { // ConstantPointerRef value...
|
2001-10-13 08:47:01 +02:00
|
|
|
unsigned Slot;
|
|
|
|
if (read_vbr(Buf, EndBuf, Slot)) return failure(true);
|
2002-07-15 01:05:09 +02:00
|
|
|
BCR_TRACE(4, "CPR: Type: '" << Ty << "' slot: " << Slot << "\n");
|
2001-10-13 08:47:01 +02:00
|
|
|
|
|
|
|
// Check to see if we have already read this global variable yet...
|
|
|
|
Value *Val = getValue(PT, Slot, false);
|
2002-07-15 01:05:09 +02:00
|
|
|
GlobalValue* GV;
|
2001-10-13 08:47:01 +02:00
|
|
|
if (Val) {
|
2002-07-15 01:05:09 +02:00
|
|
|
if (!(GV = dyn_cast<GlobalValue>(Val))) return failure(true);
|
|
|
|
BCR_TRACE(5, "Value Found in ValueTable!\n");
|
|
|
|
} else { // Nope... find or create a forward ref. for it
|
|
|
|
GV = fwdRefs.GetFwdRefToGlobal(PT, Slot);
|
2001-10-13 08:47:01 +02:00
|
|
|
}
|
2001-12-03 23:26:30 +01:00
|
|
|
V = ConstantPointerRef::get(GV);
|
2001-10-13 08:47:01 +02:00
|
|
|
break;
|
|
|
|
}
|
2002-07-15 01:05:09 +02:00
|
|
|
|
2001-10-13 08:47:01 +02:00
|
|
|
default:
|
2001-12-14 17:30:51 +01:00
|
|
|
BCR_TRACE(5, "UNKNOWN Pointer Constant Type!\n");
|
2001-10-13 08:47:01 +02:00
|
|
|
return failure(true);
|
|
|
|
}
|
2001-10-01 00:46:54 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-06-06 22:29:01 +02:00
|
|
|
default:
|
2002-06-25 22:44:04 +02:00
|
|
|
std::cerr << __FILE__ << ":" << __LINE__
|
2002-06-30 18:04:37 +02:00
|
|
|
<< ": Don't know how to deserialize constant value of type '"
|
|
|
|
<< Ty->getName() << "'\n";
|
2001-07-28 19:50:18 +02:00
|
|
|
return failure(true);
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
2001-09-07 18:37:43 +02:00
|
|
|
|
2001-06-06 22:29:01 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BytecodeParser::ParseConstantPool(const uchar *&Buf, const uchar *EndBuf,
|
2001-09-07 18:37:43 +02:00
|
|
|
ValueTable &Tab,
|
|
|
|
TypeValuesListTy &TypeTab) {
|
2001-06-06 22:29:01 +02:00
|
|
|
while (Buf < EndBuf) {
|
|
|
|
unsigned NumEntries, Typ;
|
|
|
|
|
|
|
|
if (read_vbr(Buf, EndBuf, NumEntries) ||
|
2001-07-28 19:50:18 +02:00
|
|
|
read_vbr(Buf, EndBuf, Typ)) return failure(true);
|
2001-06-06 22:29:01 +02:00
|
|
|
const Type *Ty = getType(Typ);
|
2001-07-28 19:50:18 +02:00
|
|
|
if (Ty == 0) return failure(true);
|
2001-09-07 18:37:43 +02:00
|
|
|
BCR_TRACE(3, "Type: '" << Ty << "' NumEntries: " << NumEntries << "\n");
|
2001-06-06 22:29:01 +02:00
|
|
|
|
2001-09-07 18:37:43 +02:00
|
|
|
if (Typ == Type::TypeTyID) {
|
|
|
|
if (parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries)) return true;
|
|
|
|
} else {
|
2001-10-24 08:21:22 +02:00
|
|
|
for (unsigned i = 0; i < NumEntries; ++i) {
|
2001-12-03 23:26:30 +01:00
|
|
|
Constant *I;
|
2002-07-15 01:05:09 +02:00
|
|
|
int Slot;
|
2001-12-03 23:26:30 +01:00
|
|
|
if (parseConstantValue(Buf, EndBuf, Ty, I)) return failure(true);
|
2002-07-15 01:05:09 +02:00
|
|
|
assert(I && "parseConstantValue returned `!failure' and NULL result");
|
2001-09-07 18:37:43 +02:00
|
|
|
BCR_TRACE(4, "Read Constant: '" << I << "'\n");
|
2002-07-15 01:05:09 +02:00
|
|
|
if ((Slot = insertValue(I, Tab)) < 0) return failure(true);
|
|
|
|
resolveRefsToConstant(I, (unsigned) Slot);
|
2001-09-07 18:37:43 +02:00
|
|
|
}
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-28 19:50:18 +02:00
|
|
|
if (Buf > EndBuf) return failure(true);
|
|
|
|
return false;
|
2001-06-06 22:29:01 +02:00
|
|
|
}
|