Use back() instead of [size()-1].

[oota-llvm.git] / lib / VMCore / Verifier.cpp

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 8cbb703a7369a5fcf9145a519575c82dcf8db091..0ce7d4c27ce921395c97491ae6f23f28ad33a560 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -594,10 +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 (N > 1) {
-    const StructType *STy = dyn_cast<StructType>(F->getReturnType());
-    Assert2(STy, "Return instr with multiple values, but return type is not "
-                 "a struct", &RI, 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());
@@ -605,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
@@ -1334,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())
@@ -1354,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()) {
@@ -1406,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)
@@ -1417,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