Teach VMCore to constant fold shufflevectors with constant operands.
[oota-llvm.git] / lib / VMCore / Verifier.cpp
index 68c30bbc638ed4bdeb456b91cdc596e7b4567c01..c3633ff97a11635c9fa916346c13d8ed5c6dda6f 100644 (file)
@@ -60,7 +60,6 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include <algorithm>
 #include <sstream>
 using namespace llvm;
 
 namespace {  // Anonymous namespace for class
-  cl::opt<bool>
-  Pedantic("verify-pedantic",
-           cl::desc("Reject code with undefined behaviour"));
-    
+  struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass {
+    static char ID; // Pass ID, replacement for typeid
+
+    PreVerifier() : FunctionPass((intptr_t)&ID) { }
+
+    // Check that the prerequisites for successful DominatorTree construction
+    // are satisfied.
+    bool runOnFunction(Function &F) {
+      bool Broken = false;
+
+      for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+        if (I->empty() || !I->back().isTerminator()) {
+          cerr << "Basic Block does not have terminator!\n";
+          WriteAsOperand(*cerr, I, true);
+          cerr << "\n";
+          Broken = true;
+        }
+      }
+
+      if (Broken)
+        abort();
+
+      return false;
+    }
+  };
+
+  char PreVerifier::ID = 0;
+  RegisterPass<PreVerifier> PreVer("preverify", "Preliminary module verification");
+  const PassInfo *PreVerifyID = PreVer.getPassInfo();
+
   struct VISIBILITY_HIDDEN
      Verifier : public FunctionPass, InstVisitor<Verifier> {
     static char ID; // Pass ID, replacement for typeid
@@ -161,6 +186,7 @@ namespace {  // Anonymous namespace for class
 
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesAll();
+      AU.addRequiredID(PreVerifyID);
       if (RealPass)
         AU.addRequired<DominatorTree>();
     }
@@ -364,90 +390,69 @@ void Verifier::visitFunction(Function &F) {
           F.getReturnType() == Type::VoidTy,
           "Functions cannot return aggregate values!", &F);
 
-  Assert1(!FT->isStructReturn() || FT->getReturnType() == Type::VoidTy,
+  Assert1(!F.isStructReturn() || FT->getReturnType() == Type::VoidTy,
           "Invalid struct-return function!", &F);
 
-  const uint16_t ReturnIncompatible =
-    ParamAttr::ByVal | ParamAttr::InReg |
-    ParamAttr::Nest  | ParamAttr::StructRet;
-
-  const uint16_t ParameterIncompatible =
-    ParamAttr::NoReturn | ParamAttr::NoUnwind;
-
-  const uint16_t MutuallyIncompatible =
-    ParamAttr::ByVal | ParamAttr::InReg |
-    ParamAttr::Nest  | ParamAttr::StructRet;
-
-  const uint16_t MutuallyIncompatible2 =
-    ParamAttr::ZExt | ParamAttr::SExt;
-
-  const uint16_t IntegerTypeOnly =
-    ParamAttr::SExt | ParamAttr::ZExt;
-
-  const uint16_t PointerTypeOnly =
-    ParamAttr::ByVal   | ParamAttr::Nest |
-    ParamAttr::NoAlias | ParamAttr::StructRet;
-
   bool SawSRet = false;
 
-  if (const ParamAttrsList *Attrs = FT->getParamAttrs()) {
-    unsigned Idx = 1;
-    bool SawNest = false;
+  if (const ParamAttrsList *Attrs = F.getParamAttrs()) {
+    Assert1(Attrs->size() &&
+            Attrs->getParamIndex(Attrs->size()-1) <= FT->getNumParams(),
+            "Function has excess attributes!", &F);
 
-    uint16_t RetI = Attrs->getParamAttrs(0) & ReturnIncompatible;
-    Assert1(!RetI, "Attribute " + Attrs->getParamAttrsText(RetI) +
-            "should not apply to functions!", &F);
-    uint16_t MutI = Attrs->getParamAttrs(0) & MutuallyIncompatible2;
-    Assert1(MutI != MutuallyIncompatible2, "Attributes" + 
-            Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
-
-    for (FunctionType::param_iterator I = FT->param_begin(), 
-         E = FT->param_end(); I != E; ++I, ++Idx) {
+    bool SawNest = false;
 
+    for (unsigned Idx = 0; Idx <= FT->getNumParams(); ++Idx) {
       uint16_t Attr = Attrs->getParamAttrs(Idx);
 
-      uint16_t ParmI = Attr & ParameterIncompatible;
-      Assert1(!ParmI, "Attribute " + Attrs->getParamAttrsText(ParmI) +
-              "should only be applied to function!", &F);
+      if (!Idx) {
+        uint16_t RetI = Attr & ParamAttr::ParameterOnly;
+        Assert1(!RetI, "Attribute " + Attrs->getParamAttrsText(RetI) +
+                "should not apply to functions!", &F);
+      } else {
+        uint16_t ParmI = Attr & ParamAttr::ReturnOnly;
+        Assert1(!ParmI, "Attribute " + Attrs->getParamAttrsText(ParmI) +
+                "should only be applied to function!", &F);
 
-      uint16_t MutI = Attr & MutuallyIncompatible;
-      Assert1(!(MutI & (MutI - 1)), "Attributes " +
-              Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
+      }
 
-      uint16_t MutI2 = Attr & MutuallyIncompatible2;
-      Assert1(MutI2 != MutuallyIncompatible2, "Attributes" + 
-              Attrs->getParamAttrsText(MutI2) + "are incompatible!", &F);
+      for (unsigned i = 0;
+           i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) {
+        uint16_t MutI = Attr & ParamAttr::MutuallyIncompatible[i];
+        Assert1(!(MutI & (MutI - 1)), "Attributes " +
+                Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
+      }
 
-      uint16_t IType = Attr & IntegerTypeOnly;
+      uint16_t IType = Attr & ParamAttr::IntegerTypeOnly;
       Assert1(!IType || FT->getParamType(Idx-1)->isInteger(),
               "Attribute " + Attrs->getParamAttrsText(IType) +
               "should only apply to Integer type!", &F);
 
-      uint16_t PType = Attr & PointerTypeOnly;
+      uint16_t PType = Attr & ParamAttr::PointerTypeOnly;
       Assert1(!PType || isa<PointerType>(FT->getParamType(Idx-1)),
               "Attribute " + Attrs->getParamAttrsText(PType) +
               "should only apply to Pointer type!", &F);
 
-      if (Attrs->paramHasAttr(Idx, ParamAttr::ByVal)) {
+      if (Attr & ParamAttr::ByVal) {
         const PointerType *Ty =
             dyn_cast<PointerType>(FT->getParamType(Idx-1));
         Assert1(!Ty || isa<StructType>(Ty->getElementType()),
                 "Attribute byval should only apply to pointer to structs!", &F);
       }
 
-      if (Attrs->paramHasAttr(Idx, ParamAttr::Nest)) {
+      if (Attr & ParamAttr::Nest) {
         Assert1(!SawNest, "More than one parameter has attribute nest!", &F);
         SawNest = true;
       }
 
-      if (Attrs->paramHasAttr(Idx, ParamAttr::StructRet)) {
+      if (Attr & ParamAttr::StructRet) {
         SawSRet = true;
         Assert1(Idx == 1, "Attribute sret not on first parameter!", &F);
       }
     }
   }
 
-  Assert1(SawSRet == FT->isStructReturn(),
+  Assert1(SawSRet == F.isStructReturn(),
           "StructReturn function with no sret attribute!", &F);
 
   // Check that this function meets the restrictions on this calling convention.
@@ -685,8 +690,16 @@ void Verifier::visitUIToFPInst(UIToFPInst &I) {
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isInteger(),"UInt2FP source must be integral", &I);
-  Assert1(DestTy->isFloatingPoint(),"UInt2FP result must be FP", &I);
+  bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+  bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+  Assert1(SrcVec == DstVec,"UIToFP source and dest must both be vector or scalar", &I);
+  Assert1(SrcTy->isIntOrIntVector(),"UIToFP source must be integer or integer vector", &I);
+  Assert1(DestTy->isFPOrFPVector(),"UIToFP result must be FP or FP vector", &I);
+
+  if (SrcVec && DstVec)
+    Assert1(cast<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+            "UIToFP source and dest vector length mismatch", &I);
 
   visitInstruction(I);
 }
@@ -696,8 +709,16 @@ void Verifier::visitSIToFPInst(SIToFPInst &I) {
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isInteger(),"SInt2FP source must be integral", &I);
-  Assert1(DestTy->isFloatingPoint(),"SInt2FP result must be FP", &I);
+  bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+  bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+  Assert1(SrcVec == DstVec,"SIToFP source and dest must both be vector or scalar", &I);
+  Assert1(SrcTy->isIntOrIntVector(),"SIToFP source must be integer or integer vector", &I);
+  Assert1(DestTy->isFPOrFPVector(),"SIToFP result must be FP or FP vector", &I);
+
+  if (SrcVec && DstVec)
+    Assert1(cast<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+            "SIToFP source and dest vector length mismatch", &I);
 
   visitInstruction(I);
 }
@@ -707,8 +728,16 @@ void Verifier::visitFPToUIInst(FPToUIInst &I) {
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isFloatingPoint(),"FP2UInt source must be FP", &I);
-  Assert1(DestTy->isInteger(),"FP2UInt result must be integral", &I);
+  bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+  bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+  Assert1(SrcVec == DstVec,"FPToUI source and dest must both be vector or scalar", &I);
+  Assert1(SrcTy->isFPOrFPVector(),"FPToUI source must be FP or FP vector", &I);
+  Assert1(DestTy->isIntOrIntVector(),"FPToUI result must be integer or integer vector", &I);
+
+  if (SrcVec && DstVec)
+    Assert1(cast<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+            "FPToUI source and dest vector length mismatch", &I);
 
   visitInstruction(I);
 }
@@ -718,8 +747,16 @@ void Verifier::visitFPToSIInst(FPToSIInst &I) {
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isFloatingPoint(),"FPToSI source must be FP", &I);
-  Assert1(DestTy->isInteger(),"FP2ToI result must be integral", &I);
+  bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+  bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+  Assert1(SrcVec == DstVec,"FPToSI source and dest must both be vector or scalar", &I);
+  Assert1(SrcTy->isFPOrFPVector(),"FPToSI source must be FP or FP vector", &I);
+  Assert1(DestTy->isIntOrIntVector(),"FPToSI result must be integer or integer vector", &I);
+
+  if (SrcVec && DstVec)
+    Assert1(cast<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+            "FPToSI source and dest vector length mismatch", &I);
 
   visitInstruction(I);
 }
@@ -811,12 +848,6 @@ void Verifier::visitCallInst(CallInst &CI) {
             CI.getOperand(i+1), FTy->getParamType(i), &CI);
 
   if (Function *F = CI.getCalledFunction()) {
-    if (Pedantic) {
-      // Verify that calling convention of Function and CallInst match
-      Assert1(F->getCallingConv() == CI.getCallingConv(),
-              "Call uses different calling convention than function", &CI);
-    }
-    
     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
       visitIntrinsicFunctionCall(ID, CI);
   }