Make the verifier reject instructions which have null pointers
[oota-llvm.git] / lib / VMCore / Verifier.cpp
index 4ff2447621e158979e934c7801e55e0b7395065e..034a0628fbaeeba1fd182070cedf77a466fd86e1 100644 (file)
@@ -198,23 +198,22 @@ namespace {
     /// this condition, do so.
     ///
     bool abortIfBroken() {
-      if (Broken) {
-        msgs << "Broken module found, ";
-        switch (action) {
-          case AbortProcessAction:
-            msgs << "compilation aborted!\n";
-            cerr << msgs.str();
-            abort();
-          case PrintMessageAction:
-            msgs << "verification continues.\n";
-            cerr << msgs.str();
-            return false;
-          case ReturnStatusAction:
-            msgs << "compilation terminated.\n";
-            return Broken;
-        }
+      if (!Broken) return false;
+      msgs << "Broken module found, ";
+      switch (action) {
+      default: assert(0 && "Unknown action");
+      case AbortProcessAction:
+        msgs << "compilation aborted!\n";
+        cerr << msgs.str();
+        abort();
+      case PrintMessageAction:
+        msgs << "verification continues.\n";
+        cerr << msgs.str();
+        return false;
+      case ReturnStatusAction:
+        msgs << "compilation terminated.\n";
+        return Broken;
       }
-      return false;
     }
 
 
@@ -225,6 +224,10 @@ namespace {
     void visitGlobalAlias(GlobalAlias &GA);
     void visitFunction(Function &F);
     void visitBasicBlock(BasicBlock &BB);
+    using InstVisitor<Verifier>::visit;
+       
+    void visit(Instruction &I);
+       
     void visitTruncInst(TruncInst &I);
     void visitZExtInst(ZExtInst &I);
     void visitSExtInst(SExtInst &I);
@@ -259,7 +262,8 @@ namespace {
     void visitUserOp2(Instruction &I) { visitUserOp1(I); }
     void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
     void visitAllocationInst(AllocationInst &AI);
-    void visitGetResultInst(GetResultInst &GRI);
+    void visitExtractValueInst(ExtractValueInst &EVI);
+    void visitInsertValueInst(InsertValueInst &IVI);
 
     void VerifyCallSite(CallSite CS);
     void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
@@ -279,7 +283,7 @@ namespace {
       }
     }
 
-    void WriteType(const Type* T ) {
+    void WriteType(const Type *T) {
       if ( !T ) return;
       WriteTypeSymbolic(msgs, T, Mod );
     }
@@ -326,11 +330,19 @@ static RegisterPass<Verifier> X("verify", "Module Verifier");
   do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0)
 
 
+void Verifier::visit(Instruction &I) {
+  for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
+    Assert1(I.getOperand(i) != 0, "Operand is null", &I);
+  InstVisitor<Verifier>::visit(I);
+}
+
+
 void Verifier::visitGlobalValue(GlobalValue &GV) {
   Assert1(!GV.isDeclaration() ||
           GV.hasExternalLinkage() ||
           GV.hasDLLImportLinkage() ||
           GV.hasExternalWeakLinkage() ||
+          GV.hasGhostLinkage() ||
           (isa<GlobalAlias>(GV) &&
            (GV.hasInternalLinkage() || GV.hasWeakLinkage())),
   "Global is external, but doesn't have external or dllimport or weak linkage!",
@@ -402,23 +414,34 @@ void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty,
   if (isReturnValue) {
     ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly;
     Assert1(!RetI, "Attribute " + ParamAttr::getAsString(RetI) +
-            "does not apply to return values!", V);
+            " does not apply to return values!", V);
   } else {
     ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly;
     Assert1(!ParmI, "Attribute " + ParamAttr::getAsString(ParmI) +
-            "only applies to return values!", V);
+            " only applies to return values!", V);
   }
 
   for (unsigned i = 0;
        i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) {
     ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i];
     Assert1(!(MutI & (MutI - 1)), "Attributes " +
-            ParamAttr::getAsString(MutI) + "are incompatible!", V);
+            ParamAttr::getAsString(MutI) + " are incompatible!", V);
   }
 
   ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty);
   Assert1(!TypeI, "Wrong type for attribute " +
           ParamAttr::getAsString(TypeI), V);
+
+  ParameterAttributes ByValI = Attrs & ParamAttr::ByVal;
+  if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
+    Assert1(!ByValI || PTy->getElementType()->isSized(),
+            "Attribute " + ParamAttr::getAsString(ByValI) +
+            " does not support unsized types!", V);
+  } else {
+    Assert1(!ByValI,
+            "Attribute " + ParamAttr::getAsString(ByValI) +
+            " only applies to parameters with pointer type!", V);
+  }
 }
 
 // VerifyFunctionAttrs - Check parameter attributes against a function type.
@@ -486,6 +509,7 @@ void Verifier::visitFunction(Function &F) {
   default:
     break;
   case CallingConv::C:
+  case CallingConv::X86_SSECall:
     break;
   case CallingConv::Fast:
   case CallingConv::Cold:
@@ -502,14 +526,13 @@ void Verifier::visitFunction(Function &F) {
     Assert2(I->getType() == FT->getParamType(i),
             "Argument value does not match function argument type!",
             I, FT->getParamType(i));
-    // Make sure no aggregates are passed by value.
     Assert1(I->getType()->isFirstClassType(),
-            "Functions cannot take aggregates as arguments by value!", I);
-   }
+            "Function arguments must have first-class types!", I);
+  }
 
   if (F.isDeclaration()) {
     Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() ||
-            F.hasExternalWeakLinkage(),
+            F.hasExternalWeakLinkage() || F.hasGhostLinkage(),
             "invalid linkage type for function declaration", &F);
   } else {
     // Verify that this function (which has a body) is not named "llvm.*".  It
@@ -662,8 +685,8 @@ void Verifier::visitTruncInst(TruncInst &I) {
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isInteger(), "Trunc only operates on integer", &I);
-  Assert1(DestTy->isInteger(), "Trunc only produces integer", &I);
+  Assert1(SrcTy->isIntOrIntVector(), "Trunc only operates on integer", &I);
+  Assert1(DestTy->isIntOrIntVector(), "Trunc only produces integer", &I);
   Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I);
 
   visitInstruction(I);
@@ -675,8 +698,8 @@ void Verifier::visitZExtInst(ZExtInst &I) {
   const Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
-  Assert1(SrcTy->isInteger(), "ZExt only operates on integer", &I);
-  Assert1(DestTy->isInteger(), "ZExt only produces an integer", &I);
+  Assert1(SrcTy->isIntOrIntVector(), "ZExt only operates on integer", &I);
+  Assert1(DestTy->isIntOrIntVector(), "ZExt only produces an integer", &I);
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
@@ -694,8 +717,8 @@ void Verifier::visitSExtInst(SExtInst &I) {
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isInteger(), "SExt only operates on integer", &I);
-  Assert1(DestTy->isInteger(), "SExt only produces an integer", &I);
+  Assert1(SrcTy->isIntOrIntVector(), "SExt only operates on integer", &I);
+  Assert1(DestTy->isIntOrIntVector(), "SExt only produces an integer", &I);
   Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I);
 
   visitInstruction(I);
@@ -709,8 +732,8 @@ void Verifier::visitFPTruncInst(FPTruncInst &I) {
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isFloatingPoint(),"FPTrunc only operates on FP", &I);
-  Assert1(DestTy->isFloatingPoint(),"FPTrunc only produces an FP", &I);
+  Assert1(SrcTy->isFPOrFPVector(),"FPTrunc only operates on FP", &I);
+  Assert1(DestTy->isFPOrFPVector(),"FPTrunc only produces an FP", &I);
   Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I);
 
   visitInstruction(I);
@@ -725,8 +748,8 @@ void Verifier::visitFPExtInst(FPExtInst &I) {
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isFloatingPoint(),"FPExt only operates on FP", &I);
-  Assert1(DestTy->isFloatingPoint(),"FPExt only produces an FP", &I);
+  Assert1(SrcTy->isFPOrFPVector(),"FPExt only operates on FP", &I);
+  Assert1(DestTy->isFPOrFPVector(),"FPExt only produces an FP", &I);
   Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I);
 
   visitInstruction(I);
@@ -929,7 +952,7 @@ void Verifier::VerifyCallSite(CallSite CS) {
 
       ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible;
       Assert1(!VArgI, "Attribute " + ParamAttr::getAsString(VArgI) +
-              "cannot be used for vararg call arguments!", I);
+              " cannot be used for vararg call arguments!", I);
     }
 
   visitInstruction(*I);
@@ -971,8 +994,10 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) {
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::AShr:
-    Assert1(B.getType()->isInteger(),
-            "Shift must return an integer result!", &B);
+    Assert1(B.getType()->isInteger() ||
+            (isa<VectorType>(B.getType()) && 
+             cast<VectorType>(B.getType())->getElementType()->isInteger()),
+            "Shifts only work with integral types!", &B);
     Assert1(B.getType() == B.getOperand(0)->getType(),
             "Shift return type must be same as operands!", &B);
     /* FALL THROUGH */
@@ -1039,9 +1064,13 @@ void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
   // Check to see if Mask is valid.
   if (const ConstantVector *MV = dyn_cast<ConstantVector>(SV.getOperand(2))) {
     for (unsigned i = 0, e = MV->getNumOperands(); i != e; ++i) {
-      Assert1(isa<ConstantInt>(MV->getOperand(i)) ||
-              isa<UndefValue>(MV->getOperand(i)),
-              "Invalid shufflevector shuffle mask!", &SV);
+      if (ConstantInt* CI = dyn_cast<ConstantInt>(MV->getOperand(i))) {
+        Assert1(!CI->uge(MV->getNumOperands()*2),
+                "Invalid shufflevector shuffle mask!", &SV);
+      } else {
+        Assert1(isa<UndefValue>(MV->getOperand(i)),
+                "Invalid shufflevector shuffle mask!", &SV);
+      }
     }
   } else {
     Assert1(isa<UndefValue>(SV.getOperand(2)) || 
@@ -1090,18 +1119,23 @@ void Verifier::visitAllocationInst(AllocationInst &AI) {
   visitInstruction(AI);
 }
 
-void Verifier::visitGetResultInst(GetResultInst &GRI) {
-  Assert1(GetResultInst::isValidOperands(GRI.getAggregateValue(),
-                                         GRI.getIndex()),
-          "Invalid GetResultInst operands!", &GRI);
-  Assert1(isa<CallInst>(GRI.getAggregateValue()) ||
-          isa<InvokeInst>(GRI.getAggregateValue()) ||
-          isa<UndefValue>(GRI.getAggregateValue()),
-          "GetResultInst operand must be a call/invoke/undef!", &GRI);
+void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
+  Assert1(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
+                                           EVI.idx_begin(), EVI.idx_end()) ==
+          EVI.getType(),
+          "Invalid ExtractValueInst operands!", &EVI);
   
-  visitInstruction(GRI);
+  visitInstruction(EVI);
 }
 
+void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
+  Assert1(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
+                                           IVI.idx_begin(), IVI.idx_end()) ==
+          IVI.getOperand(1)->getType(),
+          "Invalid InsertValueInst operands!", &IVI);
+  
+  visitInstruction(IVI);
+}
 
 /// verifyInstruction - Verify that an instruction is well formed.
 ///
@@ -1151,20 +1185,7 @@ void Verifier::visitInstruction(Instruction &I) {
     // Check to make sure that only first-class-values are operands to
     // instructions.
     if (!I.getOperand(i)->getType()->isFirstClassType()) {
-      if (isa<ReturnInst>(I) || isa<GetResultInst>(I))
-        Assert1(isa<StructType>(I.getOperand(i)->getType()),
-                "Invalid ReturnInst operands!", &I);
-      else if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
-        if (const PointerType *PT = dyn_cast<PointerType>
-            (I.getOperand(i)->getType())) {
-          const Type *ETy = PT->getElementType();
-          Assert1(isa<StructType>(ETy), "Invalid CallInst operands!", &I);
-        }
-        else
-          Assert1(0, "Invalid CallInst operands!", &I);
-      }
-      else
-        Assert1(0, "Instruction operands must be first-class values!", &I);
+      Assert1(0, "Instruction operands must be first-class values!", &I);
     }
     
     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
@@ -1239,7 +1260,7 @@ void Verifier::visitInstruction(Instruction &I) {
         }
 
         // Definition must dominate use unless use is unreachable!
-        Assert2(DT->dominates(Op, &I) ||
+        Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) ||
                 !DT->dominates(&BB->getParent()->getEntryBlock(), BB),
                 "Instruction does not dominate all uses!", Op, &I);
       } else {
@@ -1272,45 +1293,29 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
   switch (ID) {
   default:
     break;
+  case Intrinsic::memcpy_i32:
+  case Intrinsic::memcpy_i64:
+  case Intrinsic::memmove_i32:
+  case Intrinsic::memmove_i64:
+  case Intrinsic::memset_i32:
+  case Intrinsic::memset_i64:
+    Assert1(isa<ConstantInt>(CI.getOperand(4)),
+            "alignment argument of memory intrinsics must be a constant int",
+            &CI);
+    break;
   case Intrinsic::gcroot:
   case Intrinsic::gcwrite:
-  case Intrinsic::gcread: {
-      Type *PtrTy    = PointerType::getUnqual(Type::Int8Ty),
-           *PtrPtrTy = PointerType::getUnqual(PtrTy);
-      
-      switch (ID) {
-      default:
-        break;
-      case Intrinsic::gcroot:
-        Assert1(CI.getOperand(1)->getType() == PtrPtrTy,
-                "Intrinsic parameter #1 is not i8**.", &CI);
-        Assert1(CI.getOperand(2)->getType() == PtrTy,
-                "Intrinsic parameter #2 is not i8*.", &CI);
-        Assert1(isa<AllocaInst>(CI.getOperand(1)->stripPointerCasts()),
-                "llvm.gcroot parameter #1 must be an alloca.", &CI);
-        Assert1(isa<Constant>(CI.getOperand(2)),
-                "llvm.gcroot parameter #2 must be a constant.", &CI);
-        break;
-      case Intrinsic::gcwrite:
-        Assert1(CI.getOperand(1)->getType() == PtrTy,
-                "Intrinsic parameter #1 is not a i8*.", &CI);
-        Assert1(CI.getOperand(2)->getType() == PtrTy,
-                "Intrinsic parameter #2 is not a i8*.", &CI);
-        Assert1(CI.getOperand(3)->getType() == PtrPtrTy,
-                "Intrinsic parameter #3 is not a i8**.", &CI);
-        break;
-      case Intrinsic::gcread:
-        Assert1(CI.getOperand(1)->getType() == PtrTy,
-                "Intrinsic parameter #1 is not a i8*.", &CI);
-        Assert1(CI.getOperand(2)->getType() == PtrPtrTy,
-                "Intrinsic parameter #2 is not a i8**.", &CI);
-        break;
-      }
+  case Intrinsic::gcread:
+    if (ID == Intrinsic::gcroot) {
+      Assert1(isa<AllocaInst>(CI.getOperand(1)->stripPointerCasts()),
+              "llvm.gcroot parameter #1 must be an alloca.", &CI);
+      Assert1(isa<Constant>(CI.getOperand(2)),
+              "llvm.gcroot parameter #2 must be a constant.", &CI);
+    }
       
-      Assert1(CI.getParent()->getParent()->hasCollector(),
-              "Enclosing function does not specify a collector algorithm.",
-              &CI);
-    } break;
+    Assert1(CI.getParent()->getParent()->hasGC(),
+            "Enclosing function does not use GC.", &CI);
+    break;
   case Intrinsic::init_trampoline:
     Assert1(isa<Function>(CI.getOperand(2)->stripPointerCasts()),
             "llvm.init_trampoline parameter #2 must resolve to a function.",
@@ -1327,7 +1332,6 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
                                         unsigned Count, ...) {
   va_list VA;
   va_start(VA, Count);
-  
   const FunctionType *FTy = F->getFunctionType();
   
   // For overloaded intrinsics, the Suffix of the function name must match the
@@ -1423,6 +1427,21 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
         else
           CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a "
                       "pointer and a pointer is required.", F);
+      }        
+    } else if (VT == MVT::iPTRAny) {
+      // Outside of TableGen, we don't distinguish iPTRAny (to any address
+      // space) and iPTR. In the verifier, we can not distinguish which case
+      // we have so allow either case to be legal.
+      if (const PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
+        Suffix += ".p" + utostr(PTyp->getAddressSpace()) + 
+        MVT::getMVT(PTyp->getElementType()).getMVTString();
+      } else {
+        if (ArgNo == 0)
+          CheckFailed("Intrinsic result type is not a "
+                      "pointer and a pointer is required.", F);
+        else
+          CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a "
+                      "pointer and a pointer is required.", F);
         break;
       }
     } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
@@ -1456,17 +1475,21 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
 
   va_end(VA);
 
-  // If we computed a Suffix then the intrinsic is overloaded and we need to 
-  // make sure that the name of the function is correct. We add the suffix to
-  // the name of the intrinsic and compare against the given function name. If
-  // they are not the same, the function name is invalid. This ensures that
-  // overloading of intrinsics uses a sane and consistent naming convention.
+  // For intrinsics without pointer arguments, if we computed a Suffix then the
+  // intrinsic is overloaded and we need to make sure that the name of the
+  // function is correct. We add the suffix to the name of the intrinsic and
+  // compare against the given function name. If they are not the same, the
+  // function name is invalid. This ensures that overloading of intrinsics
+  // uses a sane and consistent naming convention.  Note that intrinsics with
+  // pointer argument may or may not be overloaded so we will check assuming it
+  // has a suffix and not.
   if (!Suffix.empty()) {
     std::string Name(Intrinsic::getName(ID));
-    if (Name + Suffix != F->getName())
+    if (Name + Suffix != F->getName()) {
       CheckFailed("Overloaded intrinsic has incorrect suffix: '" +
                   F->getName().substr(Name.length()) + "'. It should be '" +
                   Suffix + "'", F);
+    }
   }
 
   // Check parameter attributes.