add reader support for a bunch of new instructions
[oota-llvm.git] / lib / Bitcode / Reader / BitcodeReader.cpp
index cbbf8b2f0b79d812f9046d273d51443a81340c19..0090d1fd0855da8f1f04f5ff9a53f2b5f5642a42 100644 (file)
@@ -15,6 +15,7 @@
 #include "BitcodeReader.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
@@ -125,10 +126,9 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
     NumOperands = Idx+1;
   }
 
-  if (Uses[Idx]) {
-    assert(Ty == getOperand(Idx)->getType() &&
-           "Type mismatch in constant table!");
-    return cast<Constant>(getOperand(Idx));
+  if (Value *V = Uses[Idx]) {
+    assert(Ty == V->getType() && "Type mismatch in constant table!");
+    return cast<Constant>(V);
   }
 
   // Create and return a placeholder, which will later be RAUW'd.
@@ -137,6 +137,28 @@ Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx,
   return C;
 }
 
+Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, const Type *Ty) {
+  if (Idx >= size()) {
+    // Insert a bunch of null values.
+    Uses.resize(Idx+1);
+    OperandList = &Uses[0];
+    NumOperands = Idx+1;
+  }
+  
+  if (Value *V = Uses[Idx]) {
+    assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!");
+    return V;
+  }
+  
+  // No type specified, must be invalid reference.
+  if (Ty == 0) return 0;
+  
+  // Create and return a placeholder, which will later be RAUW'd.
+  Value *V = new Argument(Ty);
+  Uses[Idx].init(V, this);
+  return V;
+}
+
 
 const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   // If the TypeID is in range, return it.
@@ -151,7 +173,6 @@ const Type *BitcodeReader::getTypeByID(unsigned ID, bool isTypeTable) {
   return TypeList.back().get();
 }
 
-
 bool BitcodeReader::ParseTypeTable() {
   if (Stream.EnterSubBlock())
     return Error("Malformed block record");
@@ -643,25 +664,15 @@ bool BitcodeReader::ParseConstants() {
     }
     }
     
-    if (NextCstNo == ValueList.size())
-      ValueList.push_back(V);
-    else if (ValueList[NextCstNo] == 0)
-      ValueList.initVal(NextCstNo, V);
-    else {
-      // If there was a forward reference to this constant, 
-      Value *OldV = ValueList[NextCstNo];
-      ValueList.setOperand(NextCstNo, V);
-      OldV->replaceAllUsesWith(V);
-      delete OldV;
-    }
-    
+    ValueList.AssignValue(V, NextCstNo);
     ++NextCstNo;
   }
 }
 
-/// ParseFunction - When we see the block for a function body, remember where it
-/// is and then skip it.  This lets us lazily deserialize the functions.
-bool BitcodeReader::ParseFunction() {
+/// RememberAndSkipFunctionBody - When we see the block for a function body,
+/// remember where it is and then skip it.  This lets us lazily deserialize the
+/// functions.
+bool BitcodeReader::RememberAndSkipFunctionBody() {
   // Get the function we are talking about.
   if (FunctionsWithBodies.empty())
     return Error("Insufficient function protos");
@@ -701,13 +712,21 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
   while (!Stream.AtEndOfStream()) {
     unsigned Code = Stream.ReadCode();
     if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of module block");
+
+      // Patch the initializers for globals and aliases up.
       ResolveGlobalAndAliasInits();
       if (!GlobalInits.empty() || !AliasInits.empty())
         return Error("Malformed global initializer set");
       if (!FunctionsWithBodies.empty())
         return Error("Too few function bodies found");
-      if (Stream.ReadBlockEnd())
-        return Error("Error at end of module block");
+
+      // Force deallocation of memory for these vectors to favor the client that
+      // want lazy deserialization.
+      std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits);
+      std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits);
+      std::vector<Function*>().swap(FunctionsWithBodies);
       return false;
     }
     
@@ -741,7 +760,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
           HasReversedFunctionsWithBodies = true;
         }
         
-        if (ParseFunction())
+        if (RememberAndSkipFunctionBody())
           return true;
         break;
       }
@@ -956,6 +975,285 @@ bool BitcodeReader::materializeFunction(Function *F, std::string *ErrInfo) {
   F->setLinkage((GlobalValue::LinkageTypes)DFII->second.second);
   DeferredFunctionInfo.erase(DFII);
   
+  if (ParseFunctionBody(F)) {
+    if (ErrInfo) *ErrInfo = ErrorString;
+    return true;
+  }
+  
+  return false;
+}
+
+Module *BitcodeReader::materializeModule(std::string *ErrInfo) {
+  DenseMap<Function*, std::pair<uint64_t, unsigned> >::iterator I = 
+    DeferredFunctionInfo.begin();
+  while (!DeferredFunctionInfo.empty()) {
+    Function *F = (*I++).first;
+    assert(F->hasNotBeenReadFromBytecode() &&
+           "Deserialized function found in map!");
+    if (materializeFunction(F, ErrInfo))
+      return 0;
+  }
+  return TheModule;
+}
+
+
+/// ParseFunctionBody - Lazily parse the specified function body block.
+bool BitcodeReader::ParseFunctionBody(Function *F) {
+  if (Stream.EnterSubBlock())
+    return Error("Malformed block record");
+  
+  unsigned ModuleValueListSize = ValueList.size();
+  
+  // Add all the function arguments to the value table.
+  for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
+    ValueList.push_back(I);
+  
+  unsigned NextValueNo = ValueList.size();
+  BasicBlock *CurBB = 0;
+  unsigned CurBBNo = 0;
+
+  // Read all the records.
+  SmallVector<uint64_t, 64> Record;
+  while (1) {
+    unsigned Code = Stream.ReadCode();
+    if (Code == bitc::END_BLOCK) {
+      if (Stream.ReadBlockEnd())
+        return Error("Error at end of function block");
+      break;
+    }
+    
+    if (Code == bitc::ENTER_SUBBLOCK) {
+      switch (Stream.ReadSubBlockID()) {
+      default:  // Skip unknown content.
+        if (Stream.SkipBlock())
+          return Error("Malformed block record");
+        break;
+      case bitc::CONSTANTS_BLOCK_ID:
+        if (ParseConstants()) return true;
+        NextValueNo = ValueList.size();
+        break;
+      case bitc::VALUE_SYMTAB_BLOCK_ID:
+        if (ParseValueSymbolTable()) return true;
+        break;
+      }
+      continue;
+    }
+    
+    if (Code == bitc::DEFINE_ABBREV) {
+      Stream.ReadAbbrevRecord();
+      continue;
+    }
+    
+    // Read a record.
+    Record.clear();
+    Instruction *I = 0;
+    switch (Stream.ReadRecord(Code, Record)) {
+    default: // Default behavior: reject
+      return Error("Unknown instruction");
+    case bitc::FUNC_CODE_DECLAREBLOCKS:     // DECLAREBLOCKS: [nblocks]
+      if (Record.size() < 1 || Record[0] == 0)
+        return Error("Invalid DECLAREBLOCKS record");
+      // Create all the basic blocks for the function.
+      FunctionBBs.resize(Record.size());
+      for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
+        FunctionBBs[i] = new BasicBlock("", F);
+      CurBB = FunctionBBs[0];
+      continue;
+      
+    case bitc::FUNC_CODE_INST_BINOP: {    // BINOP: [opcode, ty, opval, opval]
+      if (Record.size() < 4) return Error("Invalid BINOP record");
+      const Type *Ty = getTypeByID(Record[1]);
+      int Opc = GetDecodedBinaryOpcode(Record[0], Ty);
+      Value *LHS = getFnValueByID(Record[2], Ty);
+      Value *RHS = getFnValueByID(Record[3], Ty);
+      if (Opc == -1 || Ty == 0 || LHS == 0 || RHS == 0)
+         return Error("Invalid BINOP record");
+      I = BinaryOperator::create((Instruction::BinaryOps)Opc, LHS, RHS);
+      break;
+    }
+    case bitc::FUNC_CODE_INST_CAST: {    // CAST: [opcode, ty, opty, opval]
+      if (Record.size() < 4) return Error("Invalid CAST record");
+      int Opc = GetDecodedCastOpcode(Record[0]);
+      const Type *ResTy = getTypeByID(Record[1]);
+      const Type *OpTy = getTypeByID(Record[2]);
+      Value *Op = getFnValueByID(Record[3], OpTy);
+      if (Opc == -1 || ResTy == 0 || OpTy == 0 || Op == 0)
+        return Error("Invalid CAST record");
+      I = CastInst::create((Instruction::CastOps)Opc, Op, ResTy);
+      break;
+    }
+    case bitc::FUNC_CODE_INST_GEP: { // GEP: [n, n x operands]
+      if (Record.size() < 2 || (Record.size() & 1))
+        return Error("Invalid GEP record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Op = getFnValueByID(Record[1], OpTy);
+      if (OpTy == 0 || Op == 0)
+        return Error("Invalid GEP record");
+
+      SmallVector<Value*, 8> GEPIdx;
+      for (unsigned i = 1, e = Record.size()/2; i != e; ++i) {
+        const Type *IdxTy = getTypeByID(Record[i*2]);
+        Value *Idx = getFnValueByID(Record[i*2+1], IdxTy);
+        if (IdxTy == 0 || Idx == 0)
+          return Error("Invalid GEP record");
+        GEPIdx.push_back(Idx);
+      }
+
+      I = new GetElementPtrInst(Op, &GEPIdx[0], GEPIdx.size());
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [ty, opval, opval, opval]
+      if (Record.size() < 4) return Error("Invalid SELECT record");
+      const Type *Ty = getTypeByID(Record[0]);
+      Value *Cond = getFnValueByID(Record[1], Type::Int1Ty);
+      Value *LHS = getFnValueByID(Record[2], Ty);
+      Value *RHS = getFnValueByID(Record[3], Ty);
+      if (Ty == 0 || Cond == 0 || LHS == 0 || RHS == 0)
+        return Error("Invalid SELECT record");
+      I = new SelectInst(Cond, LHS, RHS);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval]
+      if (Record.size() < 3) return Error("Invalid EXTRACTELT record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *Vec = getFnValueByID(Record[1], OpTy);
+      Value *Idx = getFnValueByID(Record[2], Type::Int32Ty);
+      if (OpTy == 0 || Vec == 0 || Idx == 0)
+        return Error("Invalid EXTRACTELT record");
+      I = new ExtractElementInst(Vec, Idx);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval]
+      if (Record.size() < 4) return Error("Invalid INSERTELT record");
+      const VectorType *OpTy = 
+        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      if (OpTy == 0) return Error("Invalid INSERTELT record");
+      Value *Vec = getFnValueByID(Record[1], OpTy);
+      Value *Elt = getFnValueByID(Record[2], OpTy->getElementType());
+      Value *Idx = getFnValueByID(Record[3], Type::Int32Ty);
+      if (Vec == 0 || Elt == 0 || Idx == 0)
+        return Error("Invalid INSERTELT record");
+      I = new InsertElementInst(Vec, Elt, Idx);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [ty,opval,opval,opval]
+      if (Record.size() < 4) return Error("Invalid SHUFFLEVEC record");
+      const VectorType *OpTy = 
+        dyn_cast_or_null<VectorType>(getTypeByID(Record[0]));
+      if (OpTy == 0) return Error("Invalid SHUFFLEVEC record");
+      Value *Vec1 = getFnValueByID(Record[1], OpTy);
+      Value *Vec2 = getFnValueByID(Record[2], OpTy);
+      Value *Mask = getFnValueByID(Record[3],
+                                   VectorType::get(Type::Int32Ty,
+                                                   OpTy->getNumElements()));
+      if (Vec1 == 0 || Vec2 == 0 || Mask == 0)
+        return Error("Invalid SHUFFLEVEC record");
+      I = new ShuffleVectorInst(Vec1, Vec2, Mask);
+      break;
+    }
+      
+    case bitc::FUNC_CODE_INST_CMP: { // CMP: [opty, opval, opval, pred]
+      if (Record.size() < 4) return Error("Invalid CMP record");
+      const Type *OpTy = getTypeByID(Record[0]);
+      Value *LHS = getFnValueByID(Record[1], OpTy);
+      Value *RHS = getFnValueByID(Record[2], OpTy);
+      if (OpTy == 0 || LHS == 0 || RHS == 0)
+        return Error("Invalid CMP record");
+      if (OpTy->isFPOrFPVector())
+        I = new FCmpInst((FCmpInst::Predicate)Record[3], LHS, RHS);
+      else
+        I = new ICmpInst((ICmpInst::Predicate)Record[3], LHS, RHS);
+      break;
+    }
+    
+    case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>]
+      if (Record.size() == 0) {
+        I = new ReturnInst();
+        break;
+      }
+      if (Record.size() == 2) {
+        const Type *OpTy = getTypeByID(Record[0]);
+        Value *Op = getFnValueByID(Record[1], OpTy);
+        if (OpTy && Op);
+        I = new ReturnInst(Op);
+        break;
+      }
+      return Error("Invalid RET record");
+#if 0
+    case bitc::FUNC_CODE_INST_BR:
+      // BR:         [opval, bb#, bb#] or [bb#]
+    case bitc::FUNC_CODE_INST_SWITCH:
+      // SWITCH:     [opty, opval, n, n x ops]
+    case bitc::FUNC_CODE_INST_INVOKE:
+      // INVOKE:     [fnty, op0,op1,op2, ...]
+    case bitc::FUNC_CODE_INST_UNWIND: // UNWIND
+      I = new UnwindInst();
+      break;
+    case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
+      I = new UnreachableInst();
+      break;
+
+    case bitc::FUNC_CODE_INST_PHI:
+      // PHI:        [ty, #ops, val0,bb0, ...]
+    case bitc::FUNC_CODE_INST_MALLOC:
+      // MALLOC:     [instty, op, align]
+    case bitc::FUNC_CODE_INST_FREE:
+      // FREE:       [opty, op]
+    case bitc::FUNC_CODE_INST_ALLOCA:
+      // ALLOCA:     [instty, op, align]
+    case bitc::FUNC_CODE_INST_LOAD:
+      // LOAD:       [opty, op, align, vol]
+    case bitc::FUNC_CODE_INST_STORE:
+      // STORE:      [ptrty,val,ptr, align, vol]
+    case bitc::FUNC_CODE_INST_CALL:
+      // CALL:       [fnty, fnid, arg0, arg1...]
+    case bitc::FUNC_CODE_INST_VAARG:
+      // VAARG:      [valistty, valist, instty]
+      break;
+#endif
+    }
+
+    // Add instruction to end of current BB.  If there is no current BB, reject
+    // this file.
+    if (CurBB == 0) {
+      delete I;
+      return Error("Invalid instruction with no BB");
+    }
+    CurBB->getInstList().push_back(I);
+    
+    // If this was a terminator instruction, move to the next block.
+    if (isa<TerminatorInst>(I)) {
+      ++CurBBNo;
+      CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0;
+    }
+    
+    // Non-void values get registered in the value table for future use.
+    if (I && I->getType() != Type::VoidTy)
+      ValueList.AssignValue(I, NextValueNo++);
+  }
+  
+  // Check the function list for unresolved values.
+  if (Argument *A = dyn_cast<Argument>(ValueList.back())) {
+    if (A->getParent() == 0) {
+      // We found at least one unresolved value.  Nuke them all to avoid leaks.
+      for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){
+        if ((A = dyn_cast<Argument>(ValueList.back())) && A->getParent() == 0) {
+          A->replaceAllUsesWith(UndefValue::get(A->getType()));
+          delete A;
+        }
+      }
+    }
+    return Error("Never resolved value found in function!");
+  }
+  
+  // Trim the value list down to the size it was before we parsed this function.
+  ValueList.shrinkTo(ModuleValueListSize);
+  std::vector<BasicBlock*>().swap(FunctionBBs);
+  
   return false;
 }