1 //===- ReadConst.cpp - Code to constants and constant pools ---------------===//
3 // This file implements functionality to deserialize constants and entire
6 // Note that this library should be as fast as possible, reentrant, and
9 //===----------------------------------------------------------------------===//
11 #include "ReaderInternals.h"
12 #include "llvm/Module.h"
13 #include "llvm/Constants.h"
16 const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
17 const unsigned char *EndBuf) {
19 if (read_vbr(Buf, EndBuf, PrimType)) throw Error_readvbr;
22 if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
26 case Type::FunctionTyID: {
28 if (read_vbr(Buf, EndBuf, Typ)) return Val;
29 const Type *RetType = getType(Typ);
30 if (RetType == 0) return Val;
33 if (read_vbr(Buf, EndBuf, NumParams)) return Val;
35 std::vector<const Type*> Params;
37 if (read_vbr(Buf, EndBuf, Typ)) return Val;
38 const Type *Ty = getType(Typ);
39 if (Ty == 0) return Val;
43 bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
44 if (isVarArg) Params.pop_back();
46 return FunctionType::get(RetType, Params, isVarArg);
48 case Type::ArrayTyID: {
50 if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
51 const Type *ElementType = getType(ElTyp);
52 if (ElementType == 0) return Val;
55 if (read_vbr(Buf, EndBuf, NumElements)) return Val;
57 BCR_TRACE(5, "Array Type Constant #" << ElTyp << " size="
58 << NumElements << "\n");
59 return ArrayType::get(ElementType, NumElements);
61 case Type::StructTyID: {
63 std::vector<const Type*> Elements;
65 if (read_vbr(Buf, EndBuf, Typ)) return Val;
66 while (Typ) { // List is terminated by void/0 typeid
67 const Type *Ty = getType(Typ);
68 if (Ty == 0) return Val;
69 Elements.push_back(Ty);
71 if (read_vbr(Buf, EndBuf, Typ)) return Val;
74 return StructType::get(Elements);
76 case Type::PointerTyID: {
78 if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
79 BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
80 const Type *ElementType = getType(ElTyp);
81 if (ElementType == 0) return Val;
82 return PointerType::get(ElementType);
85 case Type::OpaqueTyID: {
86 return OpaqueType::get();
90 std::cerr << __FILE__ << ":" << __LINE__
91 << ": Don't know how to deserialize"
92 << " primitive Type " << PrimType << "\n";
97 // refineAbstractType - The callback method is invoked when one of the
98 // elements of TypeValues becomes more concrete...
100 void BytecodeParser::refineAbstractType(const DerivedType *OldType,
101 const Type *NewType) {
102 TypeValuesListTy::iterator I = find(FunctionTypeValues.begin(),
103 FunctionTypeValues.end(), OldType);
104 if (I == FunctionTypeValues.end()) {
105 I = find(ModuleTypeValues.begin(), ModuleTypeValues.end(), OldType);
106 assert(I != ModuleTypeValues.end() &&
107 "Can't refine a type I don't know about!");
110 I->removeUserFromConcrete();
111 *I = NewType; // Update to point to new, more refined type.
116 // parseTypeConstants - We have to use this weird code to handle recursive
117 // types. We know that recursive types will only reference the current slab of
118 // values in the type plane, but they can forward reference types before they
119 // have been read. For example, Type #0 might be '{ Ty#1 }' and Type #1 might
120 // be 'Ty#0*'. When reading Type #0, type number one doesn't exist. To fix
121 // this ugly problem, we pessimistically insert an opaque type for each type we
122 // are about to read. This means that forward references will resolve to
123 // something and when we reread the type later, we can replace the opaque type
124 // with a new resolved concrete type.
126 void debug_type_tables();
127 void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
128 const unsigned char *EndBuf,
129 TypeValuesListTy &Tab,
130 unsigned NumEntries) {
131 assert(Tab.size() == 0 && "should not have read type constants in before!");
133 // Insert a bunch of opaque types to be resolved later...
134 for (unsigned i = 0; i < NumEntries; ++i)
135 Tab.push_back(PATypeHandle(OpaqueType::get(), this));
137 // Loop through reading all of the types. Forward types will make use of the
138 // opaque types just inserted.
140 for (unsigned i = 0; i < NumEntries; ++i) {
141 const Type *NewTy = parseTypeConstant(Buf, EndBuf), *OldTy = Tab[i].get();
142 if (NewTy == 0) throw std::string("Parsed invalid type.");
143 BCR_TRACE(4, "#" << i << ": Read Type Constant: '" << NewTy <<
144 "' Replacing: " << OldTy << "\n");
146 // Don't insertValue the new type... instead we want to replace the opaque
147 // type with the new concrete value...
150 // Refine the abstract type to the new type. This causes all uses of the
151 // abstract type to use the newty. This also will cause the opaque type
154 ((DerivedType*)Tab[i].get())->refineAbstractTypeTo(NewTy);
156 // This should have replace the old opaque type with the new type in the
157 // value table... or with a preexisting type that was already in the system
158 assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
161 BCR_TRACE(5, "Resulting types:\n");
162 for (unsigned i = 0; i < NumEntries; ++i) {
163 BCR_TRACE(5, (void*)Tab[i].get() << " - " << Tab[i].get() << "\n");
169 void BytecodeParser::parseConstantValue(const unsigned char *&Buf,
170 const unsigned char *EndBuf,
171 const Type *Ty, Constant *&V) {
173 // We must check for a ConstantExpr before switching by type because
174 // a ConstantExpr can be of any type, and has no explicit value.
176 unsigned isExprNumArgs; // 0 if not expr; numArgs if is expr
177 if (read_vbr(Buf, EndBuf, isExprNumArgs)) throw Error_readvbr;
179 // FIXME: Encoding of constant exprs could be much more compact!
181 std::vector<Constant*> ArgVec;
182 ArgVec.reserve(isExprNumArgs);
183 if (read_vbr(Buf, EndBuf, Opcode)) throw Error_readvbr;
185 // Read the slot number and types of each of the arguments
186 for (unsigned i = 0; i != isExprNumArgs; ++i) {
187 unsigned ArgValSlot, ArgTypeSlot;
188 if (read_vbr(Buf, EndBuf, ArgValSlot)) throw Error_readvbr;
189 if (read_vbr(Buf, EndBuf, ArgTypeSlot)) throw Error_readvbr;
190 const Type *ArgTy = getType(ArgTypeSlot);
191 if (ArgTy == 0) throw std::string("Argument type slot not found.");
193 BCR_TRACE(4, "CE Arg " << i << ": Type: '" << ArgTy << "' slot: "
194 << ArgValSlot << "\n");
196 // Get the arg value from its slot if it exists, otherwise a placeholder
197 Constant *C = getConstantValue(ArgTy, ArgValSlot);
198 if (C == 0) throw std::string("No arg value or placeholder found.");
202 // Construct a ConstantExpr of the appropriate kind
203 if (isExprNumArgs == 1) { // All one-operand expressions
204 assert(Opcode == Instruction::Cast);
205 V = ConstantExpr::getCast(ArgVec[0], Ty);
206 } else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
207 std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
208 V = ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
209 } else { // All other 2-operand expressions
210 V = ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
215 // Ok, not an ConstantExpr. We now know how to read the given type...
216 switch (Ty->getPrimitiveID()) {
217 case Type::BoolTyID: {
219 if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
220 if (Val != 0 && Val != 1) throw std::string("Invalid boolean value read.");
221 V = ConstantBool::get(Val == 1);
225 case Type::UByteTyID: // Unsigned integer types...
226 case Type::UShortTyID:
227 case Type::UIntTyID: {
229 if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
230 if (!ConstantUInt::isValueValidForType(Ty, Val))
231 throw std::string("Invalid unsigned byte/short/int read.");
232 V = ConstantUInt::get(Ty, Val);
236 case Type::ULongTyID: {
238 if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
239 V = ConstantUInt::get(Ty, Val);
243 case Type::SByteTyID: // Signed integer types...
244 case Type::ShortTyID:
245 case Type::IntTyID: {
248 if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
249 if (!ConstantSInt::isValueValidForType(Ty, Val))
250 throw std::string("Invalid signed byte/short/int/long read.");
251 V = ConstantSInt::get(Ty, Val);
255 case Type::FloatTyID: {
257 if (input_data(Buf, EndBuf, &F, &F+1)) throw Error_inputdata;
258 V = ConstantFP::get(Ty, F);
262 case Type::DoubleTyID: {
264 if (input_data(Buf, EndBuf, &Val, &Val+1)) throw Error_inputdata;
265 V = ConstantFP::get(Ty, Val);
270 assert(0 && "Type constants should be handled separately!!!");
273 case Type::ArrayTyID: {
274 const ArrayType *AT = cast<ArrayType>(Ty);
275 unsigned NumElements = AT->getNumElements();
277 std::vector<Constant*> Elements;
278 while (NumElements--) { // Read all of the elements of the constant.
280 if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
281 Constant *C = getConstantValue(AT->getElementType(), Slot);
282 if (!C) throw std::string("Unable to get const value of array slot.");
283 Elements.push_back(C);
285 V = ConstantArray::get(AT, Elements);
289 case Type::StructTyID: {
290 const StructType *ST = cast<StructType>(Ty);
291 const StructType::ElementTypes &ET = ST->getElementTypes();
293 std::vector<Constant *> Elements;
294 for (unsigned i = 0; i < ET.size(); ++i) {
296 if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
297 Constant *C = getConstantValue(ET[i], Slot);
298 if (!C) throw std::string("Could not read const value in struct slot.");
299 Elements.push_back(C);
302 V = ConstantStruct::get(ST, Elements);
306 case Type::PointerTyID: {
307 const PointerType *PT = cast<PointerType>(Ty);
309 if (HasImplicitZeroInitializer)
312 if (read_vbr(Buf, EndBuf, SubClass)) throw Error_readvbr;
315 case 0: // ConstantPointerNull value...
316 V = ConstantPointerNull::get(PT);
319 case 1: { // ConstantPointerRef value...
321 if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
322 BCR_TRACE(4, "CPR: Type: '" << Ty << "' slot: " << Slot << "\n");
324 // Check to see if we have already read this global variable...
325 Value *Val = getValue(PT, Slot, false);
328 if (!(GV = dyn_cast<GlobalValue>(Val)))
329 throw std::string("Value of ConstantPointerRef not in ValueTable!");
330 BCR_TRACE(5, "Value Found in ValueTable!\n");
331 } else if (RevisionNum > 0) {
332 // Revision #0 could have forward references to globals that were weird.
333 // We got rid of this in subsequent revs.
334 throw std::string("Forward references to globals not allowed.");
335 } else { // Nope... find or create a forward ref. for it
336 GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PT, Slot));
338 if (I != GlobalRefs.end()) {
339 BCR_TRACE(5, "Previous forward ref found!\n");
340 GV = cast<GlobalValue>(I->second);
342 BCR_TRACE(5, "Creating new forward ref to a global variable!\n");
344 // Create a placeholder for the global variable reference...
345 GlobalVariable *GVar =
346 new GlobalVariable(PT->getElementType(), false,
347 GlobalValue::InternalLinkage);
349 // Keep track of the fact that we have a forward ref to recycle it
350 GlobalRefs.insert(std::make_pair(std::make_pair(PT, Slot), GVar));
352 // Must temporarily push this value into the module table...
353 TheModule->getGlobalList().push_back(GVar);
358 V = ConstantPointerRef::get(GV);
363 BCR_TRACE(5, "UNKNOWN Pointer Constant Type!\n");
364 throw std::string("Unknown pointer constant type.");
370 std::cerr << __FILE__ << ":" << __LINE__
371 << ": Don't know how to deserialize constant value of type '"
372 << Ty->getName() << "'\n";
373 throw std::string("Don't know how to deserialize constant value of type '"+
378 void BytecodeParser::ParseGlobalTypes(const unsigned char *&Buf,
379 const unsigned char *EndBuf) {
381 ParseConstantPool(Buf, EndBuf, T, ModuleTypeValues);
384 void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
385 const unsigned char *EndBuf,
387 TypeValuesListTy &TypeTab) {
388 while (Buf < EndBuf) {
389 unsigned NumEntries, Typ;
391 if (read_vbr(Buf, EndBuf, NumEntries) ||
392 read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
393 const Type *Ty = getType(Typ);
394 if (Ty == 0) throw std::string("Invalid type read.");
395 BCR_TRACE(3, "Type: '" << Ty << "' NumEntries: " << NumEntries << "\n");
397 if (Typ == Type::TypeTyID) {
398 parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
400 for (unsigned i = 0; i < NumEntries; ++i) {
403 parseConstantValue(Buf, EndBuf, Ty, C);
404 assert(C && "parseConstantValue returned NULL!");
405 BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
406 if ((Slot = insertValue(C, Tab)) == -1)
407 throw std::string("Could not insert value into ValueTable.");
409 // If we are reading a function constant table, make sure that we adjust
410 // the slot number to be the real global constant number.
412 if (&Tab != &ModuleValues && Typ < ModuleValues.size())
413 Slot += ModuleValues[Typ]->size();
414 ResolveReferencesToValue(C, (unsigned)Slot);
419 if (Buf > EndBuf) throw std::string("Read past end of buffer.");