lib/Bytecode/Reader/ConstantReader.cpp

   1 //===- ReadConst.cpp - Code to constants and constant pools ---------------===//
   2 //
   3 // This file implements functionality to deserialize constants and entire
   4 // constant pools.
   5 //
   6 // Note that this library should be as fast as possible, reentrant, and
   7 // thread-safe!!
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #include "ReaderInternals.h"
  12 #include "llvm/Module.h"
  13 #include "llvm/Constants.h"
  14 #include <algorithm>
  15
  16 const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
  17                                               const unsigned char *EndBuf) {
  18   unsigned PrimType;
  19   if (read_vbr(Buf, EndBuf, PrimType)) throw Error_readvbr;
  20
  21   const Type *Val = 0;
  22   if ((Val = Type::getPrimitiveType((Type::PrimitiveID)PrimType)))
  23     return Val;
  24
  25   switch (PrimType) {
  26   case Type::FunctionTyID: {
  27     unsigned Typ;
  28     if (read_vbr(Buf, EndBuf, Typ)) return Val;
  29     const Type *RetType = getType(Typ);
  30     if (RetType == 0) return Val;
  31
  32     unsigned NumParams;
  33     if (read_vbr(Buf, EndBuf, NumParams)) return Val;
  34
  35     std::vector<const Type*> Params;
  36     while (NumParams--) {
  37       if (read_vbr(Buf, EndBuf, Typ)) return Val;
  38       const Type *Ty = getType(Typ);
  39       if (Ty == 0) return Val;
  40       Params.push_back(Ty);
  41     }
  42
  43     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
  44     if (isVarArg) Params.pop_back();
  45
  46     return FunctionType::get(RetType, Params, isVarArg);
  47   }
  48   case Type::ArrayTyID: {
  49     unsigned ElTyp;
  50     if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
  51     const Type *ElementType = getType(ElTyp);
  52     if (ElementType == 0) return Val;
  53
  54     unsigned NumElements;
  55     if (read_vbr(Buf, EndBuf, NumElements)) return Val;
  56
  57     BCR_TRACE(5, "Array Type Constant #" << ElTyp << " size="
  58               << NumElements << "\n");
  59     return ArrayType::get(ElementType, NumElements);
  60   }
  61   case Type::StructTyID: {
  62     unsigned Typ;
  63     std::vector<const Type*> Elements;
  64
  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);
  70
  71       if (read_vbr(Buf, EndBuf, Typ)) return Val;
  72     }
  73
  74     return StructType::get(Elements);
  75   }
  76   case Type::PointerTyID: {
  77     unsigned ElTyp;
  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);
  83   }
  84
  85   case Type::OpaqueTyID: {
  86     return OpaqueType::get();
  87   }
  88
  89   default:
  90     std::cerr << __FILE__ << ":" << __LINE__
  91               << ": Don't know how to deserialize"
  92               << " primitive Type " << PrimType << "\n";
  93     return Val;
  94   }
  95 }
  96
  97 // parseTypeConstants - We have to use this weird code to handle recursive
  98 // types.  We know that recursive types will only reference the current slab of
  99 // values in the type plane, but they can forward reference types before they
 100 // have been read.  For example, Type #0 might be '{ Ty#1 }' and Type #1 might
 101 // be 'Ty#0*'.  When reading Type #0, type number one doesn't exist.  To fix
 102 // this ugly problem, we pessimistically insert an opaque type for each type we
 103 // are about to read.  This means that forward references will resolve to
 104 // something and when we reread the type later, we can replace the opaque type
 105 // with a new resolved concrete type.
 106 //
 107 void debug_type_tables();
 108 void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
 109                                         const unsigned char *EndBuf,
 110                                         TypeValuesListTy &Tab,
 111                                         unsigned NumEntries) {
 112   assert(Tab.size() == 0 && "should not have read type constants in before!");
 113
 114   // Insert a bunch of opaque types to be resolved later...
 115   for (unsigned i = 0; i < NumEntries; ++i)
 116     Tab.push_back(OpaqueType::get());
 117
 118   // Loop through reading all of the types.  Forward types will make use of the
 119   // opaque types just inserted.
 120   //
 121   for (unsigned i = 0; i < NumEntries; ++i) {
 122     const Type *NewTy = parseTypeConstant(Buf, EndBuf), *OldTy = Tab[i].get();
 123     if (NewTy == 0) throw std::string("Parsed invalid type.");
 124     BCR_TRACE(4, "#" << i << ": Read Type Constant: '" << NewTy <<
 125               "' Replacing: " << OldTy << "\n");
 126
 127     // Don't insertValue the new type... instead we want to replace the opaque
 128     // type with the new concrete value...
 129     //
 130
 131     // Refine the abstract type to the new type.  This causes all uses of the
 132     // abstract type to use the newty.  This also will cause the opaque type
 133     // to be deleted...
 134     //
 135     ((DerivedType*)Tab[i].get())->refineAbstractTypeTo(NewTy);
 136
 137     // This should have replace the old opaque type with the new type in the
 138     // value table... or with a preexisting type that was already in the system
 139     assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
 140   }
 141
 142   BCR_TRACE(5, "Resulting types:\n");
 143   for (unsigned i = 0; i < NumEntries; ++i) {
 144     BCR_TRACE(5, (void*)Tab[i].get() << " - " << Tab[i].get() << "\n");
 145   }
 146   debug_type_tables();
 147 }
 148
 149
 150 Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
 151                                              const unsigned char *EndBuf,
 152                                              const Type *Ty) {
 153
 154   // We must check for a ConstantExpr before switching by type because
 155   // a ConstantExpr can be of any type, and has no explicit value.
 156   //
 157   unsigned isExprNumArgs;               // 0 if not expr; numArgs if is expr
 158   if (read_vbr(Buf, EndBuf, isExprNumArgs)) throw Error_readvbr;
 159   if (isExprNumArgs) {
 160     // FIXME: Encoding of constant exprs could be much more compact!
 161     unsigned Opcode;
 162     std::vector<Constant*> ArgVec;
 163     ArgVec.reserve(isExprNumArgs);
 164     if (read_vbr(Buf, EndBuf, Opcode)) throw Error_readvbr;
 165
 166     // Read the slot number and types of each of the arguments
 167     for (unsigned i = 0; i != isExprNumArgs; ++i) {
 168       unsigned ArgValSlot, ArgTypeSlot;
 169       if (read_vbr(Buf, EndBuf, ArgValSlot)) throw Error_readvbr;
 170       if (read_vbr(Buf, EndBuf, ArgTypeSlot)) throw Error_readvbr;
 171       const Type *ArgTy = getType(ArgTypeSlot);
 172       if (ArgTy == 0) throw std::string("Argument type slot not found.");
 173
 174       BCR_TRACE(4, "CE Arg " << i << ": Type: '" << ArgTy << "'  slot: "
 175                 << ArgValSlot << "\n");
 176
 177       // Get the arg value from its slot if it exists, otherwise a placeholder
 178       Constant *C = getConstantValue(ArgTy, ArgValSlot);
 179       if (C == 0) throw std::string("No arg value or placeholder found.");
 180       ArgVec.push_back(C);
 181     }
 182
 183     // Construct a ConstantExpr of the appropriate kind
 184     if (isExprNumArgs == 1) {           // All one-operand expressions
 185       assert(Opcode == Instruction::Cast);
 186       return ConstantExpr::getCast(ArgVec[0], Ty);
 187     } else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
 188       std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
 189       return ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
 190     } else {                            // All other 2-operand expressions
 191       return ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
 192     }
 193   }
 194
 195   // Ok, not an ConstantExpr.  We now know how to read the given type...
 196   switch (Ty->getPrimitiveID()) {
 197   case Type::BoolTyID: {
 198     unsigned Val;
 199     if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
 200     if (Val != 0 && Val != 1) throw std::string("Invalid boolean value read.");
 201     return ConstantBool::get(Val == 1);
 202   }
 203
 204   case Type::UByteTyID:   // Unsigned integer types...
 205   case Type::UShortTyID:
 206   case Type::UIntTyID: {
 207     unsigned Val;
 208     if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
 209     if (!ConstantUInt::isValueValidForType(Ty, Val))
 210       throw std::string("Invalid unsigned byte/short/int read.");
 211     return ConstantUInt::get(Ty, Val);
 212   }
 213
 214   case Type::ULongTyID: {
 215     uint64_t Val;
 216     if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
 217     return ConstantUInt::get(Ty, Val);
 218   }
 219
 220   case Type::SByteTyID:   // Signed integer types...
 221   case Type::ShortTyID:
 222   case Type::IntTyID: {
 223   case Type::LongTyID:
 224     int64_t Val;
 225     if (read_vbr(Buf, EndBuf, Val)) throw Error_readvbr;
 226     if (!ConstantSInt::isValueValidForType(Ty, Val))
 227       throw std::string("Invalid signed byte/short/int/long read.");
 228     return ConstantSInt::get(Ty, Val);
 229   }
 230
 231   case Type::FloatTyID: {
 232     float F;
 233     if (input_data(Buf, EndBuf, &F, &F+1)) throw Error_inputdata;
 234     return ConstantFP::get(Ty, F);
 235   }
 236
 237   case Type::DoubleTyID: {
 238     double Val;
 239     if (input_data(Buf, EndBuf, &Val, &Val+1)) throw Error_inputdata;
 240     return ConstantFP::get(Ty, Val);
 241   }
 242
 243   case Type::TypeTyID:
 244     throw std::string("Type constants shouldn't live in constant table!");
 245
 246   case Type::ArrayTyID: {
 247     const ArrayType *AT = cast<ArrayType>(Ty);
 248     unsigned NumElements = AT->getNumElements();
 249
 250     std::vector<Constant*> Elements;
 251     while (NumElements--) {   // Read all of the elements of the constant.
 252       unsigned Slot;
 253       if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
 254       Constant *C = getConstantValue(AT->getElementType(), Slot);
 255       if (!C) throw std::string("Unable to get const value of array slot.");
 256       Elements.push_back(C);
 257     }
 258     return ConstantArray::get(AT, Elements);
 259   }
 260
 261   case Type::StructTyID: {
 262     const StructType *ST = cast<StructType>(Ty);
 263     const StructType::ElementTypes &ET = ST->getElementTypes();
 264
 265     std::vector<Constant *> Elements;
 266     for (unsigned i = 0; i < ET.size(); ++i) {
 267       unsigned Slot;
 268       if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
 269       Constant *C = getConstantValue(ET[i], Slot);
 270       if (!C) throw std::string("Could not read const value in struct slot.");
 271       Elements.push_back(C);
 272     }
 273
 274     return ConstantStruct::get(ST, Elements);
 275   }
 276
 277   case Type::PointerTyID: {
 278     const PointerType *PT = cast<PointerType>(Ty);
 279     unsigned SubClass;
 280     if (HasImplicitZeroInitializer)
 281       SubClass = 1;
 282     else
 283       if (read_vbr(Buf, EndBuf, SubClass)) throw Error_readvbr;
 284
 285     switch (SubClass) {
 286     case 0:    // ConstantPointerNull value...
 287       return ConstantPointerNull::get(PT);
 288
 289     case 1: {  // ConstantPointerRef value...
 290       unsigned Slot;
 291       if (read_vbr(Buf, EndBuf, Slot)) throw Error_readvbr;
 292       BCR_TRACE(4, "CPR: Type: '" << Ty << "'  slot: " << Slot << "\n");
 293
 294       // Check to see if we have already read this global variable...
 295       Value *Val = getValue(PT, Slot, false);
 296       GlobalValue *GV;
 297       if (Val) {
 298         if (!(GV = dyn_cast<GlobalValue>(Val)))
 299           throw std::string("Value of ConstantPointerRef not in ValueTable!");
 300         BCR_TRACE(5, "Value Found in ValueTable!\n");
 301       } else if (RevisionNum > 0) {
 302         // Revision #0 could have forward references to globals that were weird.
 303         // We got rid of this in subsequent revs.
 304         throw std::string("Forward references to globals not allowed.");
 305       } else {         // Nope... find or create a forward ref. for it
 306         GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PT, Slot));
 307
 308         if (I != GlobalRefs.end()) {
 309           BCR_TRACE(5, "Previous forward ref found!\n");
 310           GV = cast<GlobalValue>(I->second);
 311         } else {
 312           BCR_TRACE(5, "Creating new forward ref to a global variable!\n");
 313
 314           // Create a placeholder for the global variable reference...
 315           GlobalVariable *GVar =
 316             new GlobalVariable(PT->getElementType(), false,
 317                                GlobalValue::InternalLinkage);
 318
 319           // Keep track of the fact that we have a forward ref to recycle it
 320           GlobalRefs.insert(std::make_pair(std::make_pair(PT, Slot), GVar));
 321
 322           // Must temporarily push this value into the module table...
 323           TheModule->getGlobalList().push_back(GVar);
 324           GV = GVar;
 325         }
 326       }
 327
 328       return ConstantPointerRef::get(GV);
 329     }
 330
 331     default:
 332       BCR_TRACE(5, "UNKNOWN Pointer Constant Type!\n");
 333       throw std::string("Unknown pointer constant type.");
 334     }
 335   }
 336
 337   default:
 338     throw std::string("Don't know how to deserialize constant value of type '"+
 339                       Ty->getDescription());
 340   }
 341 }
 342
 343 void BytecodeParser::ParseGlobalTypes(const unsigned char *&Buf,
 344                                       const unsigned char *EndBuf) {
 345   ValueTable T;
 346   ParseConstantPool(Buf, EndBuf, T, ModuleTypeValues);
 347 }
 348
 349 void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
 350                                        const unsigned char *EndBuf,
 351                                        ValueTable &Tab,
 352                                        TypeValuesListTy &TypeTab) {
 353   while (Buf < EndBuf) {
 354     unsigned NumEntries, Typ;
 355
 356     if (read_vbr(Buf, EndBuf, NumEntries) ||
 357         read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
 358     const Type *Ty = getType(Typ);
 359     if (Ty == 0) throw std::string("Invalid type read.");
 360     BCR_TRACE(3, "Type: '" << Ty << "'  NumEntries: " << NumEntries << "\n");
 361
 362     if (Typ == Type::TypeTyID) {
 363       parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
 364     } else {
 365       for (unsigned i = 0; i < NumEntries; ++i) {
 366         Constant *C = parseConstantValue(Buf, EndBuf, Ty);
 367         assert(C && "parseConstantValue returned NULL!");
 368         BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
 369         int Slot;
 370         if ((Slot = insertValue(C, Tab)) == -1)
 371           throw std::string("Could not insert value into ValueTable.");
 372
 373         // If we are reading a function constant table, make sure that we adjust
 374         // the slot number to be the real global constant number.
 375         //
 376         if (&Tab != &ModuleValues && Typ < ModuleValues.size())
 377           Slot += ModuleValues[Typ]->size();
 378         ResolveReferencesToValue(C, (unsigned)Slot);
 379       }
 380     }
 381   }
 382
 383   if (Buf > EndBuf) throw std::string("Read past end of buffer.");
 384 }