X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FVerifier.cpp;h=0ce7d4c27ce921395c97491ae6f23f28ad33a560;hb=719de53742167ca3f0e6b2efafb6eac18bd90452;hp=aec5974209b9a18e96e7951b0cb8d88ec46452c6;hpb=018f77139892111d36ecf5580856dba4cc4b75d1;p=oota-llvm.git

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index aec5974209b..0ce7d4c27ce 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -92,11 +92,14 @@ namespace {  // Anonymous namespace for class
       return false;
     }
   };
+}
 
-  char PreVerifier::ID = 0;
-  RegisterPass<PreVerifier> PreVer("preverify", "Preliminary module verification");
-  const PassInfo *PreVerifyID = PreVer.getPassInfo();
+char PreVerifier::ID = 0;
+static RegisterPass<PreVerifier>
+PreVer("preverify", "Preliminary module verification");
+static const PassInfo *const PreVerifyID = &PreVer;
 
+namespace {
   struct VISIBILITY_HIDDEN
      Verifier : public FunctionPass, InstVisitor<Verifier> {
     static char ID; // Pass ID, replacement for typeid
@@ -305,11 +308,10 @@ namespace {  // Anonymous namespace for class
       Broken = true;
     }
   };
-
-  char Verifier::ID = 0;
-  RegisterPass<Verifier> X("verify", "Module Verifier");
 } // End anonymous namespace
 
+char Verifier::ID = 0;
+static RegisterPass<Verifier> X("verify", "Module Verifier");
 
 // Assert - We know that cond should be true, if not print an error message.
 #define Assert(C, M) \
@@ -592,7 +594,10 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
     Assert2(N == 0,
             "Found return instr that returns void in Function of non-void "
             "return type!", &RI, F->getReturnType());
-  else if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
+  else if (N == 1 && F->getReturnType() == RI.getOperand(0)->getType()) {
+    // Exactly one return value and it matches the return type. Good.
+  } else if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
+    // The return type is a struct; check for multiple return values.
     Assert2(STy->getNumElements() == N,
             "Incorrect number of return values in ret instruction!",
             &RI, F->getReturnType());
@@ -600,10 +605,18 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
       Assert2(STy->getElementType(i) == RI.getOperand(i)->getType(),
               "Function return type does not match operand "
               "type of return inst!", &RI, F->getReturnType());
+  } else if (const ArrayType *ATy = dyn_cast<ArrayType>(F->getReturnType())) {
+    // The return type is an array; check for multiple return values.
+    Assert2(ATy->getNumElements() == N,
+            "Incorrect number of return values in ret instruction!",
+            &RI, F->getReturnType());
+    for (unsigned i = 0; i != N; ++i)
+      Assert2(ATy->getElementType() == RI.getOperand(i)->getType(),
+              "Function return type does not match operand "
+              "type of return inst!", &RI, F->getReturnType());
   } else {
-    Assert2(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
-            "Function return type does not match operand "
-            "type of return inst!", &RI, F->getReturnType());
+    CheckFailed("Function return type does not match operand "
+                "type of return inst!", &RI, F->getReturnType());
   }
   
   // Check to make sure that the return value has necessary properties for
@@ -1043,7 +1056,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
   const Type *ElTy =
     GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
-                                      Idxs.begin(), Idxs.end(), true);
+                                      Idxs.begin(), Idxs.end());
   Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
   Assert2(isa<PointerType>(GEP.getType()) &&
           cast<PointerType>(GEP.getType())->getElementType() == ElTy,
@@ -1329,7 +1342,7 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
 
   // Note that "arg#0" is the return type.
   for (unsigned ArgNo = 0; ArgNo < Count; ++ArgNo) {
-    MVT::ValueType VT = va_arg(VA, MVT::ValueType);
+    int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
 
     if (VT == MVT::isVoid && ArgNo > 0) {
       if (!FTy->isVarArg())
@@ -1349,8 +1362,8 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
       EltTy = VTy->getElementType();
       NumElts = VTy->getNumElements();
     }
-    
-    if ((int)VT < 0) {
+
+    if (VT < 0) {
       int Match = ~VT;
       if (Match == 0) {
         if (Ty != FTy->getReturnType()) {
@@ -1401,7 +1414,7 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
       Suffix += ".";
       if (EltTy != Ty)
         Suffix += "v" + utostr(NumElts);
-      Suffix += MVT::getValueTypeString(MVT::getValueType(EltTy));
+      Suffix += MVT::getMVT(EltTy).getMVTString();
     } else if (VT == MVT::iPTR) {
       if (!isa<PointerType>(Ty)) {
         if (ArgNo == 0)
@@ -1412,19 +1425,20 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
                       "pointer and a pointer is required.", F);
         break;
       }
-    } else if (MVT::isVector(VT)) {
+    } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
+      MVT VVT = MVT((MVT::SimpleValueType)VT);
       // If this is a vector argument, verify the number and type of elements.
-      if (MVT::getVectorElementType(VT) != MVT::getValueType(EltTy)) {
+      if (VVT.getVectorElementType() != MVT::getMVT(EltTy)) {
         CheckFailed("Intrinsic prototype has incorrect vector element type!",
                     F);
         break;
       }
-      if (MVT::getVectorNumElements(VT) != NumElts) {
+      if (VVT.getVectorNumElements() != NumElts) {
         CheckFailed("Intrinsic prototype has incorrect number of "
                     "vector elements!",F);
         break;
       }
-    } else if (MVT::getTypeForValueType(VT) != EltTy) {
+    } else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) {
       if (ArgNo == 0)
         CheckFailed("Intrinsic prototype has incorrect result type!", F);
       else