Split EVT into MVT and EVT, the former representing _just_ a primitive type, while

the latter is capable of representing either a primitive or an extended type.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78713 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 89 insertions, 89 deletions

diff --git a/lib/VMCore/ValueTypes.cpp b/lib/VMCore/ValueTypes.cpp
index de3b640..952d225 100644
--- a/lib/VMCore/ValueTypes.cpp
+++ b/lib/VMCore/ValueTypes.cpp
@@ -82,7 +82,7 @@ unsigned EVT::getExtendedSizeInBits() const {
 
 /// getEVTString - This function returns value type as a string, e.g. "i32".
 std::string EVT::getEVTString() const {
-  switch (V) {
+  switch (V.SimpleTy) {
   default:
     if (isVector())
       return "v" + utostr(getVectorNumElements()) +
@@ -91,40 +91,40 @@ std::string EVT::getEVTString() const {
       return "i" + utostr(getSizeInBits());
     llvm_unreachable("Invalid EVT!");
     return "?";
-  case EVT::i1:      return "i1";
-  case EVT::i8:      return "i8";
-  case EVT::i16:     return "i16";
-  case EVT::i32:     return "i32";
-  case EVT::i64:     return "i64";
-  case EVT::i128:    return "i128";
-  case EVT::f32:     return "f32";
-  case EVT::f64:     return "f64";
-  case EVT::f80:     return "f80";
-  case EVT::f128:    return "f128";
-  case EVT::ppcf128: return "ppcf128";
-  case EVT::isVoid:  return "isVoid";
-  case EVT::Other:   return "ch";
-  case EVT::Flag:    return "flag";
-  case EVT::v2i8:    return "v2i8";
-  case EVT::v4i8:    return "v4i8";
-  case EVT::v8i8:    return "v8i8";
-  case EVT::v16i8:   return "v16i8";
-  case EVT::v32i8:   return "v32i8";
-  case EVT::v2i16:   return "v2i16";
-  case EVT::v4i16:   return "v4i16";
-  case EVT::v8i16:   return "v8i16";
-  case EVT::v16i16:  return "v16i16";
-  case EVT::v2i32:   return "v2i32";
-  case EVT::v4i32:   return "v4i32";
-  case EVT::v8i32:   return "v8i32";
-  case EVT::v1i64:   return "v1i64";
-  case EVT::v2i64:   return "v2i64";
-  case EVT::v4i64:   return "v4i64";
-  case EVT::v2f32:   return "v2f32";
-  case EVT::v4f32:   return "v4f32";
-  case EVT::v8f32:   return "v8f32";
-  case EVT::v2f64:   return "v2f64";
-  case EVT::v4f64:   return "v4f64";
+  case MVT::i1:      return "i1";
+  case MVT::i8:      return "i8";
+  case MVT::i16:     return "i16";
+  case MVT::i32:     return "i32";
+  case MVT::i64:     return "i64";
+  case MVT::i128:    return "i128";
+  case MVT::f32:     return "f32";
+  case MVT::f64:     return "f64";
+  case MVT::f80:     return "f80";
+  case MVT::f128:    return "f128";
+  case MVT::ppcf128: return "ppcf128";
+  case MVT::isVoid:  return "isVoid";
+  case MVT::Other:   return "ch";
+  case MVT::Flag:    return "flag";
+  case MVT::v2i8:    return "v2i8";
+  case MVT::v4i8:    return "v4i8";
+  case MVT::v8i8:    return "v8i8";
+  case MVT::v16i8:   return "v16i8";
+  case MVT::v32i8:   return "v32i8";
+  case MVT::v2i16:   return "v2i16";
+  case MVT::v4i16:   return "v4i16";
+  case MVT::v8i16:   return "v8i16";
+  case MVT::v16i16:  return "v16i16";
+  case MVT::v2i32:   return "v2i32";
+  case MVT::v4i32:   return "v4i32";
+  case MVT::v8i32:   return "v8i32";
+  case MVT::v1i64:   return "v1i64";
+  case MVT::v2i64:   return "v2i64";
+  case MVT::v4i64:   return "v4i64";
+  case MVT::v2f32:   return "v2f32";
+  case MVT::v4f32:   return "v4f32";
+  case MVT::v8f32:   return "v8f32";
+  case MVT::v2f64:   return "v2f64";
+  case MVT::v4f64:   return "v4f64";
   }
 }
 
@@ -132,64 +132,64 @@ std::string EVT::getEVTString() const {
 /// specified EVT.  For integer types, this returns an unsigned type.  Note
 /// that this will abort for types that cannot be represented.
 const Type *EVT::getTypeForEVT() const {
-  switch (V) {
+  switch (V.SimpleTy) {
   default:
     assert(isExtended() && "Type is not extended!");
     return LLVMTy;
-  case EVT::isVoid:  return Type::VoidTy;
-  case EVT::i1:      return Type::Int1Ty;
-  case EVT::i8:      return Type::Int8Ty;
-  case EVT::i16:     return Type::Int16Ty;
-  case EVT::i32:     return Type::Int32Ty;
-  case EVT::i64:     return Type::Int64Ty;
-  case EVT::i128:    return IntegerType::get(128);
-  case EVT::f32:     return Type::FloatTy;
-  case EVT::f64:     return Type::DoubleTy;
-  case EVT::f80:     return Type::X86_FP80Ty;
-  case EVT::f128:    return Type::FP128Ty;
-  case EVT::ppcf128: return Type::PPC_FP128Ty;
-  case EVT::v2i8:    return VectorType::get(Type::Int8Ty, 2);
-  case EVT::v4i8:    return VectorType::get(Type::Int8Ty, 4);
-  case EVT::v8i8:    return VectorType::get(Type::Int8Ty, 8);
-  case EVT::v16i8:   return VectorType::get(Type::Int8Ty, 16);
-  case EVT::v32i8:   return VectorType::get(Type::Int8Ty, 32);
-  case EVT::v2i16:   return VectorType::get(Type::Int16Ty, 2);
-  case EVT::v4i16:   return VectorType::get(Type::Int16Ty, 4);
-  case EVT::v8i16:   return VectorType::get(Type::Int16Ty, 8);
-  case EVT::v16i16:  return VectorType::get(Type::Int16Ty, 16);
-  case EVT::v2i32:   return VectorType::get(Type::Int32Ty, 2);
-  case EVT::v4i32:   return VectorType::get(Type::Int32Ty, 4);
-  case EVT::v8i32:   return VectorType::get(Type::Int32Ty, 8);
-  case EVT::v1i64:   return VectorType::get(Type::Int64Ty, 1);
-  case EVT::v2i64:   return VectorType::get(Type::Int64Ty, 2);
-  case EVT::v4i64:   return VectorType::get(Type::Int64Ty, 4);
-  case EVT::v2f32:   return VectorType::get(Type::FloatTy, 2);
-  case EVT::v4f32:   return VectorType::get(Type::FloatTy, 4);
-  case EVT::v8f32:   return VectorType::get(Type::FloatTy, 8);
-  case EVT::v2f64:   return VectorType::get(Type::DoubleTy, 2);
-  case EVT::v4f64:   return VectorType::get(Type::DoubleTy, 4); 
+  case MVT::isVoid:  return Type::VoidTy;
+  case MVT::i1:      return Type::Int1Ty;
+  case MVT::i8:      return Type::Int8Ty;
+  case MVT::i16:     return Type::Int16Ty;
+  case MVT::i32:     return Type::Int32Ty;
+  case MVT::i64:     return Type::Int64Ty;
+  case MVT::i128:    return IntegerType::get(128);
+  case MVT::f32:     return Type::FloatTy;
+  case MVT::f64:     return Type::DoubleTy;
+  case MVT::f80:     return Type::X86_FP80Ty;
+  case MVT::f128:    return Type::FP128Ty;
+  case MVT::ppcf128: return Type::PPC_FP128Ty;
+  case MVT::v2i8:    return VectorType::get(Type::Int8Ty, 2);
+  case MVT::v4i8:    return VectorType::get(Type::Int8Ty, 4);
+  case MVT::v8i8:    return VectorType::get(Type::Int8Ty, 8);
+  case MVT::v16i8:   return VectorType::get(Type::Int8Ty, 16);
+  case MVT::v32i8:   return VectorType::get(Type::Int8Ty, 32);
+  case MVT::v2i16:   return VectorType::get(Type::Int16Ty, 2);
+  case MVT::v4i16:   return VectorType::get(Type::Int16Ty, 4);
+  case MVT::v8i16:   return VectorType::get(Type::Int16Ty, 8);
+  case MVT::v16i16:  return VectorType::get(Type::Int16Ty, 16);
+  case MVT::v2i32:   return VectorType::get(Type::Int32Ty, 2);
+  case MVT::v4i32:   return VectorType::get(Type::Int32Ty, 4);
+  case MVT::v8i32:   return VectorType::get(Type::Int32Ty, 8);
+  case MVT::v1i64:   return VectorType::get(Type::Int64Ty, 1);
+  case MVT::v2i64:   return VectorType::get(Type::Int64Ty, 2);
+  case MVT::v4i64:   return VectorType::get(Type::Int64Ty, 4);
+  case MVT::v2f32:   return VectorType::get(Type::FloatTy, 2);
+  case MVT::v4f32:   return VectorType::get(Type::FloatTy, 4);
+  case MVT::v8f32:   return VectorType::get(Type::FloatTy, 8);
+  case MVT::v2f64:   return VectorType::get(Type::DoubleTy, 2);
+  case MVT::v4f64:   return VectorType::get(Type::DoubleTy, 4); 
  }
 }
 
 /// getEVT - Return the value type corresponding to the specified type.  This
-/// returns all pointers as EVT::iPTR.  If HandleUnknown is true, unknown types
+/// returns all pointers as MVT::iPTR.  If HandleUnknown is true, unknown types
 /// are returned as Other, otherwise they are invalid.
 EVT EVT::getEVT(const Type *Ty, bool HandleUnknown){
   switch (Ty->getTypeID()) {
   default:
-    if (HandleUnknown) return EVT::Other;
+    if (HandleUnknown) return MVT(MVT::Other);
     llvm_unreachable("Unknown type!");
-    return EVT::isVoid;
+    return MVT(MVT::isVoid);
   case Type::VoidTyID:
-    return EVT::isVoid;
+    return MVT(MVT::isVoid);
   case Type::IntegerTyID:
     return getIntegerVT(cast<IntegerType>(Ty)->getBitWidth());
-  case Type::FloatTyID:     return EVT::f32;
-  case Type::DoubleTyID:    return EVT::f64;
-  case Type::X86_FP80TyID:  return EVT::f80;
-  case Type::FP128TyID:     return EVT::f128;
-  case Type::PPC_FP128TyID: return EVT::ppcf128;
-  case Type::PointerTyID:   return EVT::iPTR;
+  case Type::FloatTyID:     return MVT(MVT::f32);
+  case Type::DoubleTyID:    return MVT(MVT::f64);
+  case Type::X86_FP80TyID:  return MVT(MVT::f80);
+  case Type::FP128TyID:     return MVT(MVT::f128);
+  case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
+  case Type::PointerTyID:   return MVT(MVT::iPTR);
   case Type::VectorTyID: {
     const VectorType *VTy = cast<VectorType>(Ty);
     return getVectorVT(getEVT(VTy->getElementType(), false),
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index ca09952..62a0a9f 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -1559,7 +1559,7 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
         return false;
       }
     }
-  } else if (VT == EVT::iAny) {
+  } else if (VT == MVT::iAny) {
     if (!EltTy->isInteger()) {
       CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
                   "an integer type.", F);
@@ -1584,7 +1584,7 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
       }
       break;
     }
-  } else if (VT == EVT::fAny) {
+  } else if (VT == MVT::fAny) {
     if (!EltTy->isFloatingPoint()) {
       CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
                   "a floating-point type.", F);
@@ -1597,19 +1597,19 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
       Suffix += "v" + utostr(NumElts);
 
     Suffix += EVT::getEVT(EltTy).getEVTString();
-  } else if (VT == EVT::vAny) {
+  } else if (VT == MVT::vAny) {
     if (!VTy) {
       CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a vector type.", F);
       return false;
     }
     Suffix += ".v" + utostr(NumElts) + EVT::getEVT(EltTy).getEVTString();
-  } else if (VT == EVT::iPTR) {
+  } else if (VT == MVT::iPTR) {
     if (!isa<PointerType>(Ty)) {
       CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
                   "pointer and a pointer is required.", F);
       return false;
     }
-  } else if (VT == EVT::iPTRAny) {
+  } 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.
@@ -1621,8 +1621,8 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
                   "pointer and a pointer is required.", F);
       return false;
     }
-  } else if (EVT((EVT::SimpleValueType)VT).isVector()) {
-    EVT VVT = EVT((EVT::SimpleValueType)VT);
+  } else if (EVT((MVT::SimpleValueType)VT).isVector()) {
+    EVT VVT = EVT((MVT::SimpleValueType)VT);
 
     // If this is a vector argument, verify the number and type of elements.
     if (VVT.getVectorElementType() != EVT::getEVT(EltTy)) {
@@ -1635,7 +1635,7 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
                   "vector elements!", F);
       return false;
     }
-  } else if (EVT((EVT::SimpleValueType)VT).getTypeForEVT() != EltTy) {
+  } else if (EVT((MVT::SimpleValueType)VT).getTypeForEVT() != EltTy) {
     CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is wrong!", F);
     return false;
   } else if (EltTy != Ty) {
@@ -1677,7 +1677,7 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
   }
 
   for (unsigned ArgNo = 0; ArgNo < RetNum; ++ArgNo) {
-    int VT = va_arg(VA, int); // An EVT::SimpleValueType when non-negative.
+    int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
 
     if (ST) Ty = ST->getElementType(ArgNo);
 
@@ -1687,9 +1687,9 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
 
   // Verify the parameter types.
   for (unsigned ArgNo = 0; ArgNo < ParamNum; ++ArgNo) {
-    int VT = va_arg(VA, int); // An EVT::SimpleValueType when non-negative.
+    int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
 
-    if (VT == EVT::isVoid && ArgNo > 0) {
+    if (VT == MVT::isVoid && ArgNo > 0) {
       if (!FTy->isVarArg())
         CheckFailed("Intrinsic prototype has no '...'!", F);
       break;