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

10 files changed, 207 insertions, 207 deletions

diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp
index af72b93fd3..29b41a243b 100644
--- a/utils/TableGen/CodeGenDAGPatterns.cpp
+++ b/utils/TableGen/CodeGenDAGPatterns.cpp
@@ -27,9 +27,9 @@ using namespace llvm;
 /// FilterVTs - Filter a list of VT's according to a predicate.
 ///
 template<typename T>
-static std::vector<EVT::SimpleValueType>
-FilterVTs(const std::vector<EVT::SimpleValueType> &InVTs, T Filter) {
-  std::vector<EVT::SimpleValueType> Result;
+static std::vector<MVT::SimpleValueType>
+FilterVTs(const std::vector<MVT::SimpleValueType> &InVTs, T Filter) {
+  std::vector<MVT::SimpleValueType> Result;
   for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
     if (Filter(InVTs[i]))
       Result.push_back(InVTs[i]);
@@ -41,28 +41,28 @@ static std::vector<unsigned char>
 FilterEVTs(const std::vector<unsigned char> &InVTs, T Filter) {
   std::vector<unsigned char> Result;
   for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
-    if (Filter((EVT::SimpleValueType)InVTs[i]))
+    if (Filter((MVT::SimpleValueType)InVTs[i]))
       Result.push_back(InVTs[i]);
   return Result;
 }
 
 static std::vector<unsigned char>
-ConvertVTs(const std::vector<EVT::SimpleValueType> &InVTs) {
+ConvertVTs(const std::vector<MVT::SimpleValueType> &InVTs) {
   std::vector<unsigned char> Result;
   for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
     Result.push_back(InVTs[i]);
   return Result;
 }
 
-static inline bool isInteger(EVT::SimpleValueType VT) {
+static inline bool isInteger(MVT::SimpleValueType VT) {
   return EVT(VT).isInteger();
 }
 
-static inline bool isFloatingPoint(EVT::SimpleValueType VT) {
+static inline bool isFloatingPoint(MVT::SimpleValueType VT) {
   return EVT(VT).isFloatingPoint();
 }
 
-static inline bool isVector(EVT::SimpleValueType VT) {
+static inline bool isVector(MVT::SimpleValueType VT) {
   return EVT(VT).isVector();
 }
 
@@ -261,11 +261,11 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     return NodeToApply->UpdateNodeType(x.SDTCisVT_Info.VT, TP);
   case SDTCisPtrTy: {
     // Operand must be same as target pointer type.
-    return NodeToApply->UpdateNodeType(EVT::iPTR, TP);
+    return NodeToApply->UpdateNodeType(MVT::iPTR, TP);
   }
   case SDTCisInt: {
     // If there is only one integer type supported, this must be it.
-    std::vector<EVT::SimpleValueType> IntVTs =
+    std::vector<MVT::SimpleValueType> IntVTs =
       FilterVTs(CGT.getLegalValueTypes(), isInteger);
 
     // If we found exactly one supported integer type, apply it.
@@ -275,7 +275,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
   }
   case SDTCisFP: {
     // If there is only one FP type supported, this must be it.
-    std::vector<EVT::SimpleValueType> FPVTs =
+    std::vector<MVT::SimpleValueType> FPVTs =
       FilterVTs(CGT.getLegalValueTypes(), isFloatingPoint);
         
     // If we found exactly one supported FP type, apply it.
@@ -297,7 +297,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
         !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
                ->isSubClassOf("ValueType"))
       TP.error(N->getOperator()->getName() + " expects a VT operand!");
-    EVT::SimpleValueType VT =
+    MVT::SimpleValueType VT =
      getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef());
     if (!isInteger(VT))
       TP.error(N->getOperator()->getName() + " VT operand must be integer!");
@@ -314,7 +314,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     // types at this point.
     assert(OtherNode->getExtTypes().size() == 1 && "Node has too many types!");
     if (OtherNode->hasTypeSet() && OtherNode->getTypeNum(0) <= VT)
-      OtherNode->UpdateNodeType(EVT::Other, TP);  // Throw an error.
+      OtherNode->UpdateNodeType(MVT::Other, TP);  // Throw an error.
     return false;
   }
   case SDTCisOpSmallerThanOp: {
@@ -341,7 +341,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     else if (EEVT::isExtFloatingPointInVTs(BigOperand->getExtTypes()))
       MadeChange |= NodeToApply->UpdateNodeType(EEVT::isFP, TP);
 
-    std::vector<EVT::SimpleValueType> VTs = CGT.getLegalValueTypes();
+    std::vector<MVT::SimpleValueType> VTs = CGT.getLegalValueTypes();
 
     if (EEVT::isExtIntegerInVTs(NodeToApply->getExtTypes())) {
       VTs = FilterVTs(VTs, isInteger);
@@ -356,7 +356,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     case 0: break;   // No info yet.
     case 1: 
       // Only one VT of this flavor.  Cannot ever satisfy the constraints.
-      return NodeToApply->UpdateNodeType(EVT::Other, TP);  // throw
+      return NodeToApply->UpdateNodeType(MVT::Other, TP);  // throw
     case 2:
       // If we have exactly two possible types, the little operand must be the
       // small one, the big operand should be the big one.  Common with 
@@ -377,7 +377,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
         TP.error(N->getOperator()->getName() + " VT operand must be a vector!");
       EVT IVT = OtherOperand->getTypeNum(0);
       IVT = IVT.getVectorElementType();
-      return NodeToApply->UpdateNodeType(IVT.getSimpleVT(), TP);
+      return NodeToApply->UpdateNodeType(IVT.getSimpleVT().SimpleTy, TP);
     }
     return false;
   }
@@ -459,8 +459,8 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
     return true;
   }
 
-  if (getExtTypeNum(0) == EVT::iPTR || getExtTypeNum(0) == EVT::iPTRAny) {
-    if (ExtVTs[0] == EVT::iPTR || ExtVTs[0] == EVT::iPTRAny ||
+  if (getExtTypeNum(0) == MVT::iPTR || getExtTypeNum(0) == MVT::iPTRAny) {
+    if (ExtVTs[0] == MVT::iPTR || ExtVTs[0] == MVT::iPTRAny ||
         ExtVTs[0] == EEVT::isInt)
       return false;
     if (EEVT::isExtIntegerInVTs(ExtVTs)) {
@@ -472,7 +472,7 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
     }
   }
 
-  if ((ExtVTs[0] == EEVT::isInt || ExtVTs[0] == EVT::iAny) &&
+  if ((ExtVTs[0] == EEVT::isInt || ExtVTs[0] == MVT::iAny) &&
       EEVT::isExtIntegerInVTs(getExtTypes())) {
     assert(hasTypeSet() && "should be handled above!");
     std::vector<unsigned char> FVTs = FilterEVTs(getExtTypes(), isInteger);
@@ -481,7 +481,7 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
     setTypes(FVTs);
     return true;
   }
-  if ((ExtVTs[0] == EVT::iPTR || ExtVTs[0] == EVT::iPTRAny) &&
+  if ((ExtVTs[0] == MVT::iPTR || ExtVTs[0] == MVT::iPTRAny) &&
       EEVT::isExtIntegerInVTs(getExtTypes())) {
     //assert(hasTypeSet() && "should be handled above!");
     std::vector<unsigned char> FVTs = FilterEVTs(getExtTypes(), isInteger);
@@ -492,7 +492,7 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
       return true;
     }
   }      
-  if ((ExtVTs[0] == EEVT::isFP || ExtVTs[0] == EVT::fAny) &&
+  if ((ExtVTs[0] == EEVT::isFP || ExtVTs[0] == MVT::fAny) &&
       EEVT::isExtFloatingPointInVTs(getExtTypes())) {
     assert(hasTypeSet() && "should be handled above!");
     std::vector<unsigned char> FVTs =
@@ -502,7 +502,7 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
     setTypes(FVTs);
     return true;
   }
-  if (ExtVTs[0] == EVT::vAny && EEVT::isExtVectorInVTs(getExtTypes())) {
+  if (ExtVTs[0] == MVT::vAny && EEVT::isExtVectorInVTs(getExtTypes())) {
     assert(hasTypeSet() && "should be handled above!");
     std::vector<unsigned char> FVTs = FilterEVTs(getExtTypes(), isVector);
     if (getExtTypes() == FVTs)
@@ -516,17 +516,17 @@ bool TreePatternNode::UpdateNodeType(const std::vector<unsigned char> &ExtVTs,
   //
   // Similarly, we should probably set the type here to the intersection of
   // {isInt|isFP} and ExtVTs
-  if (((getExtTypeNum(0) == EEVT::isInt || getExtTypeNum(0) == EVT::iAny) &&
+  if (((getExtTypeNum(0) == EEVT::isInt || getExtTypeNum(0) == MVT::iAny) &&
        EEVT::isExtIntegerInVTs(ExtVTs)) ||
-      ((getExtTypeNum(0) == EEVT::isFP || getExtTypeNum(0) == EVT::fAny) &&
+      ((getExtTypeNum(0) == EEVT::isFP || getExtTypeNum(0) == MVT::fAny) &&
        EEVT::isExtFloatingPointInVTs(ExtVTs)) ||
-      (getExtTypeNum(0) == EVT::vAny &&
+      (getExtTypeNum(0) == MVT::vAny &&
        EEVT::isExtVectorInVTs(ExtVTs))) {
     setTypes(ExtVTs);
     return true;
   }
   if (getExtTypeNum(0) == EEVT::isInt &&
-      (ExtVTs[0] == EVT::iPTR || ExtVTs[0] == EVT::iPTRAny)) {
+      (ExtVTs[0] == MVT::iPTR || ExtVTs[0] == MVT::iPTRAny)) {
     setTypes(ExtVTs);
     return true;
   }
@@ -553,16 +553,16 @@ void TreePatternNode::print(raw_ostream &OS) const {
   // FIXME: At some point we should handle printing all the value types for 
   // nodes that are multiply typed.
   switch (getExtTypeNum(0)) {
-  case EVT::Other: OS << ":Other"; break;
+  case MVT::Other: OS << ":Other"; break;
   case EEVT::isInt: OS << ":isInt"; break;
   case EEVT::isFP : OS << ":isFP"; break;
   case EEVT::isUnknown: ; /*OS << ":?";*/ break;
-  case EVT::iPTR:  OS << ":iPTR"; break;
-  case EVT::iPTRAny:  OS << ":iPTRAny"; break;
+  case MVT::iPTR:  OS << ":iPTR"; break;
+  case MVT::iPTRAny:  OS << ":iPTRAny"; break;
   default: {
     std::string VTName = llvm::getName(getTypeNum(0));
     // Strip off EVT:: prefix if present.
-    if (VTName.substr(0,5) == "EVT::")
+    if (VTName.substr(0,5) == "MVT::")
       VTName = VTName.substr(5);
     OS << ":" << VTName;
     break;
@@ -744,7 +744,7 @@ static std::vector<unsigned char> getImplicitType(Record *R, bool NotRegisters,
                                       TreePattern &TP) {
   // Some common return values
   std::vector<unsigned char> Unknown(1, EEVT::isUnknown);
-  std::vector<unsigned char> Other(1, EVT::Other);
+  std::vector<unsigned char> Other(1, MVT::Other);
 
   // Check to see if this is a register or a register class...
   if (R->isSubClassOf("RegisterClass")) {
@@ -771,7 +771,7 @@ static std::vector<unsigned char> getImplicitType(Record *R, bool NotRegisters,
     ComplexPat(1, TP.getDAGPatterns().getComplexPattern(R).getValueType());
     return ComplexPat;
   } else if (R->isSubClassOf("PointerLikeRegClass")) {
-    Other[0] = EVT::iPTR;
+    Other[0] = MVT::iPTR;
     return Other;
   } else if (R->getName() == "node" || R->getName() == "srcvalue" ||
              R->getName() == "zero_reg") {
@@ -827,12 +827,12 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
         // multiple types.  Assert here that it does not, so we revisit this
         // code when appropriate.
         assert(getExtTypes().size() >= 1 && "TreePattern doesn't have a type!");
-        EVT::SimpleValueType VT = getTypeNum(0);
+        MVT::SimpleValueType VT = getTypeNum(0);
         for (unsigned i = 1, e = getExtTypes().size(); i != e; ++i)
           assert(getTypeNum(i) == VT && "TreePattern has too many types!");
         
         VT = getTypeNum(0);
-        if (VT != EVT::iPTR && VT != EVT::iPTRAny) {
+        if (VT != MVT::iPTR && VT != MVT::iPTRAny) {
           unsigned Size = EVT(VT).getSizeInBits();
           // Make sure that the value is representable for this type.
           if (Size < 32) {
@@ -873,7 +873,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
                                                 TP);
       MadeChange |= getChild(NC-1)->UpdateNodeType(getChild(i)->getExtTypes(),
                                                    TP);
-      MadeChange |= UpdateNodeType(EVT::isVoid, TP);
+      MadeChange |= UpdateNodeType(MVT::isVoid, TP);
     }
     return MadeChange;
   } else if (getOperator()->getName() == "implicit" ||
@@ -881,7 +881,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
     bool MadeChange = false;
     for (unsigned i = 0; i < getNumChildren(); ++i)
       MadeChange = getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
-    MadeChange |= UpdateNodeType(EVT::isVoid, TP);
+    MadeChange |= UpdateNodeType(MVT::isVoid, TP);
     return MadeChange;
   } else if (getOperator()->getName() == "COPY_TO_REGCLASS") {
     bool MadeChange = false;
@@ -905,10 +905,10 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
                utostr(getNumChildren() - 1) + " operands!");
 
     // Apply type info to the intrinsic ID.
-    MadeChange |= getChild(0)->UpdateNodeType(EVT::iPTR, TP);
+    MadeChange |= getChild(0)->UpdateNodeType(MVT::iPTR, TP);
     
     for (unsigned i = NumRetVTs, e = getNumChildren(); i != e; ++i) {
-      EVT::SimpleValueType OpVT = Int->IS.ParamVTs[i - NumRetVTs];
+      MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i - NumRetVTs];
       MadeChange |= getChild(i)->UpdateNodeType(OpVT, TP);
       MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters);
     }
@@ -922,7 +922,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
     // Branch, etc. do not produce results and top-level forms in instr pattern
     // must have void types.
     if (NI.getNumResults() == 0)
-      MadeChange |= UpdateNodeType(EVT::isVoid, TP);
+      MadeChange |= UpdateNodeType(MVT::isVoid, TP);
     
     return MadeChange;  
   } else if (getOperator()->isSubClassOf("Instruction")) {
@@ -937,13 +937,13 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
       CDP.getTargetInfo().getInstruction(getOperator()->getName());
     // Apply the result type to the node
     if (NumResults == 0 || InstInfo.NumDefs == 0) {
-      MadeChange = UpdateNodeType(EVT::isVoid, TP);
+      MadeChange = UpdateNodeType(MVT::isVoid, TP);
     } else {
       Record *ResultNode = Inst.getResult(0);
       
       if (ResultNode->isSubClassOf("PointerLikeRegClass")) {
         std::vector<unsigned char> VT;
-        VT.push_back(EVT::iPTR);
+        VT.push_back(MVT::iPTR);
         MadeChange = UpdateNodeType(VT, TP);
       } else if (ResultNode->getName() == "unknown") {
         std::vector<unsigned char> VT;
@@ -976,7 +976,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
         TP.error("Instruction '" + getOperator()->getName() +
                  "' expects more operands than were provided.");
       
-      EVT::SimpleValueType VT;
+      MVT::SimpleValueType VT;
       TreePatternNode *Child = getChild(ChildNo++);
       if (OperandNode->isSubClassOf("RegisterClass")) {
         const CodeGenRegisterClass &RC = 
@@ -986,7 +986,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
         VT = getValueType(OperandNode->getValueAsDef("Type"));
         MadeChange |= Child->UpdateNodeType(VT, TP);
       } else if (OperandNode->isSubClassOf("PointerLikeRegClass")) {
-        MadeChange |= Child->UpdateNodeType(EVT::iPTR, TP);
+        MadeChange |= Child->UpdateNodeType(MVT::iPTR, TP);
       } else if (OperandNode->getName() == "unknown") {
         MadeChange |= Child->UpdateNodeType(EEVT::isUnknown, TP);
       } else {
@@ -1227,7 +1227,7 @@ TreePatternNode *TreePattern::ParseTreePattern(DagInit *Dag) {
 
     // If this intrinsic returns void, it must have side-effects and thus a
     // chain.
-    if (Int.IS.RetVTs[0] == EVT::isVoid) {
+    if (Int.IS.RetVTs[0] == MVT::isVoid) {
       Operator = getDAGPatterns().get_intrinsic_void_sdnode();
     } else if (Int.ModRef != CodeGenIntrinsic::NoMem) {
       // Has side-effects, requires chain.
@@ -1585,7 +1585,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
     // If this is not a set, verify that the children nodes are not void typed,
     // and recurse.
     for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) {
-      if (Pat->getChild(i)->getExtTypeNum(0) == EVT::isVoid)
+      if (Pat->getChild(i)->getExtTypeNum(0) == MVT::isVoid)
         I->error("Cannot have void nodes inside of patterns!");
       FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults,
                                   InstImpInputs, InstImpResults);
@@ -1833,7 +1833,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
     // fill in the InstResults map.
     for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) {
       TreePatternNode *Pat = I->getTree(j);
-      if (Pat->getExtTypeNum(0) != EVT::isVoid)
+      if (Pat->getExtTypeNum(0) != MVT::isVoid)
         I->error("Top-level forms in instruction pattern should have"
                  " void types");
 
diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h
index 6dbc7596c6..7c2791d440 100644
--- a/utils/TableGen/CodeGenDAGPatterns.h
+++ b/utils/TableGen/CodeGenDAGPatterns.h
@@ -34,10 +34,10 @@ namespace llvm {
   class ComplexPattern;
 
 /// EEVT::DAGISelGenValueType - These are some extended forms of
-/// EVT::SimpleValueType that we use as lattice values during type inference.
+/// MVT::SimpleValueType that we use as lattice values during type inference.
 namespace EEVT {
   enum DAGISelGenValueType {
-    isFP  = EVT::LAST_VALUETYPE,
+    isFP  = MVT::LAST_VALUETYPE,
     isInt,
     isUnknown
   };
@@ -181,19 +181,19 @@ public:
   
   bool isLeaf() const { return Val != 0; }
   bool hasTypeSet() const {
-    return (Types[0] < EVT::LAST_VALUETYPE) || (Types[0] == EVT::iPTR) || 
-          (Types[0] == EVT::iPTRAny);
+    return (Types[0] < MVT::LAST_VALUETYPE) || (Types[0] == MVT::iPTR) || 
+          (Types[0] == MVT::iPTRAny);
   }
   bool isTypeCompletelyUnknown() const {
     return Types[0] == EEVT::isUnknown;
   }
   bool isTypeDynamicallyResolved() const {
-    return (Types[0] == EVT::iPTR) || (Types[0] == EVT::iPTRAny);
+    return (Types[0] == MVT::iPTR) || (Types[0] == MVT::iPTRAny);
   }
-  EVT::SimpleValueType getTypeNum(unsigned Num) const {
+  MVT::SimpleValueType getTypeNum(unsigned Num) const {
     assert(hasTypeSet() && "Doesn't have a type yet!");
     assert(Types.size() > Num && "Type num out of range!");
-    return (EVT::SimpleValueType)Types[Num];
+    return (MVT::SimpleValueType)Types[Num];
   }
   unsigned char getExtTypeNum(unsigned Num) const { 
     assert(Types.size() > Num && "Extended type num out of range!");
diff --git a/utils/TableGen/CodeGenIntrinsics.h b/utils/TableGen/CodeGenIntrinsics.h
index 685e141f99..7e7bdf989a 100644
--- a/utils/TableGen/CodeGenIntrinsics.h
+++ b/utils/TableGen/CodeGenIntrinsics.h
@@ -37,20 +37,20 @@ namespace llvm {
     /// continues from there through the parameter list. This is useful for
     /// "matching" types.
     struct IntrinsicSignature {
-      /// RetVTs - The EVT::SimpleValueType for each return type. Note that this
+      /// RetVTs - The MVT::SimpleValueType for each return type. Note that this
       /// list is only populated when in the context of a target .td file. When
       /// building Intrinsics.td, this isn't available, because we don't know
       /// the target pointer size.
-      std::vector<EVT::SimpleValueType> RetVTs;
+      std::vector<MVT::SimpleValueType> RetVTs;
 
       /// RetTypeDefs - The records for each return type.
       std::vector<Record*> RetTypeDefs;
 
-      /// ParamVTs - The EVT::SimpleValueType for each parameter type. Note that
+      /// ParamVTs - The MVT::SimpleValueType for each parameter type. Note that
       /// this list is only populated when in the context of a target .td file.
       /// When building Intrinsics.td, this isn't available, because we don't
       /// know the target pointer size.
-      std::vector<EVT::SimpleValueType> ParamVTs;
+      std::vector<MVT::SimpleValueType> ParamVTs;
 
       /// ParamTypeDefs - The records for each parameter type.
       std::vector<Record*> ParamTypeDefs;
diff --git a/utils/TableGen/CodeGenRegisters.h b/utils/TableGen/CodeGenRegisters.h
index a52da6e50b..6f8682be59 100644
--- a/utils/TableGen/CodeGenRegisters.h
+++ b/utils/TableGen/CodeGenRegisters.h
@@ -36,7 +36,7 @@ namespace llvm {
     Record *TheDef;
     std::string Namespace;
     std::vector<Record*> Elements;
-    std::vector<EVT::SimpleValueType> VTs;
+    std::vector<MVT::SimpleValueType> VTs;
     unsigned SpillSize;
     unsigned SpillAlignment;
     int CopyCost;
@@ -44,10 +44,10 @@ namespace llvm {
     std::string MethodProtos, MethodBodies;
 
     const std::string &getName() const;
-    const std::vector<EVT::SimpleValueType> &getValueTypes() const {return VTs;}
+    const std::vector<MVT::SimpleValueType> &getValueTypes() const {return VTs;}
     unsigned getNumValueTypes() const { return VTs.size(); }
     
-    EVT::SimpleValueType getValueTypeNum(unsigned VTNum) const {
+    MVT::SimpleValueType getValueTypeNum(unsigned VTNum) const {
       if (VTNum < VTs.size())
         return VTs[VTNum];
       assert(0 && "VTNum greater than number of ValueTypes in RegClass!");
diff --git a/utils/TableGen/CodeGenTarget.cpp b/utils/TableGen/CodeGenTarget.cpp
index 9b639ecd8d..a3ec8dc41d 100644
--- a/utils/TableGen/CodeGenTarget.cpp
+++ b/utils/TableGen/CodeGenTarget.cpp
@@ -30,63 +30,63 @@ static cl::opt<unsigned>
 AsmWriterNum("asmwriternum", cl::init(0),
              cl::desc("Make -gen-asm-writer emit assembly writer #N"));
 
-/// getValueType - Return the EVT::SimpleValueType that the specified TableGen
+/// getValueType - Return the MVT::SimpleValueType that the specified TableGen
 /// record corresponds to.
-EVT::SimpleValueType llvm::getValueType(Record *Rec) {
-  return (EVT::SimpleValueType)Rec->getValueAsInt("Value");
+MVT::SimpleValueType llvm::getValueType(Record *Rec) {
+  return (MVT::SimpleValueType)Rec->getValueAsInt("Value");
 }
 
-std::string llvm::getName(EVT::SimpleValueType T) {
+std::string llvm::getName(MVT::SimpleValueType T) {
   switch (T) {
-  case EVT::Other:   return "UNKNOWN";
-  case EVT::iPTR:    return "TLI.getPointerTy()";
-  case EVT::iPTRAny: return "TLI.getPointerTy()";
+  case MVT::Other:   return "UNKNOWN";
+  case MVT::iPTR:    return "TLI.getPointerTy()";
+  case MVT::iPTRAny: return "TLI.getPointerTy()";
   default: return getEnumName(T);
   }
 }
 
-std::string llvm::getEnumName(EVT::SimpleValueType T) {
+std::string llvm::getEnumName(MVT::SimpleValueType T) {
   switch (T) {
-  case EVT::Other: return "EVT::Other";
-  case EVT::i1:    return "EVT::i1";
-  case EVT::i8:    return "EVT::i8";
-  case EVT::i16:   return "EVT::i16";
-  case EVT::i32:   return "EVT::i32";
-  case EVT::i64:   return "EVT::i64";
-  case EVT::i128:  return "EVT::i128";
-  case EVT::iAny:  return "EVT::iAny";
-  case EVT::fAny:  return "EVT::fAny";
-  case EVT::vAny:  return "EVT::vAny";
-  case EVT::f32:   return "EVT::f32";
-  case EVT::f64:   return "EVT::f64";
-  case EVT::f80:   return "EVT::f80";
-  case EVT::f128:  return "EVT::f128";
-  case EVT::ppcf128:  return "EVT::ppcf128";
-  case EVT::Flag:  return "EVT::Flag";
-  case EVT::isVoid:return "EVT::isVoid";
-  case EVT::v2i8:  return "EVT::v2i8";
-  case EVT::v4i8:  return "EVT::v4i8";
-  case EVT::v8i8:  return "EVT::v8i8";
-  case EVT::v16i8: return "EVT::v16i8";
-  case EVT::v32i8: return "EVT::v32i8";
-  case EVT::v2i16: return "EVT::v2i16";
-  case EVT::v4i16: return "EVT::v4i16";
-  case EVT::v8i16: return "EVT::v8i16";
-  case EVT::v16i16: return "EVT::v16i16";
-  case EVT::v2i32: return "EVT::v2i32";
-  case EVT::v4i32: return "EVT::v4i32";
-  case EVT::v8i32: return "EVT::v8i32";
-  case EVT::v1i64: return "EVT::v1i64";
-  case EVT::v2i64: return "EVT::v2i64";
-  case EVT::v4i64: return "EVT::v4i64";
-  case EVT::v2f32: return "EVT::v2f32";
-  case EVT::v4f32: return "EVT::v4f32";
-  case EVT::v8f32: return "EVT::v8f32";
-  case EVT::v2f64: return "EVT::v2f64";
-  case EVT::v4f64: return "EVT::v4f64";
-  case EVT::Metadata: return "EVT::Metadata";
-  case EVT::iPTR:  return "EVT::iPTR";
-  case EVT::iPTRAny:  return "EVT::iPTRAny";
+  case MVT::Other: return "MVT::Other";
+  case MVT::i1:    return "MVT::i1";
+  case MVT::i8:    return "MVT::i8";
+  case MVT::i16:   return "MVT::i16";
+  case MVT::i32:   return "MVT::i32";
+  case MVT::i64:   return "MVT::i64";
+  case MVT::i128:  return "MVT::i128";
+  case MVT::iAny:  return "MVT::iAny";
+  case MVT::fAny:  return "MVT::fAny";
+  case MVT::vAny:  return "MVT::vAny";
+  case MVT::f32:   return "MVT::f32";
+  case MVT::f64:   return "MVT::f64";
+  case MVT::f80:   return "MVT::f80";
+  case MVT::f128:  return "MVT::f128";
+  case MVT::ppcf128:  return "MVT::ppcf128";
+  case MVT::Flag:  return "MVT::Flag";
+  case MVT::isVoid:return "MVT::isVoid";
+  case MVT::v2i8:  return "MVT::v2i8";
+  case MVT::v4i8:  return "MVT::v4i8";
+  case MVT::v8i8:  return "MVT::v8i8";
+  case MVT::v16i8: return "MVT::v16i8";
+  case MVT::v32i8: return "MVT::v32i8";
+  case MVT::v2i16: return "MVT::v2i16";
+  case MVT::v4i16: return "MVT::v4i16";
+  case MVT::v8i16: return "MVT::v8i16";
+  case MVT::v16i16: return "MVT::v16i16";
+  case MVT::v2i32: return "MVT::v2i32";
+  case MVT::v4i32: return "MVT::v4i32";
+  case MVT::v8i32: return "MVT::v8i32";
+  case MVT::v1i64: return "MVT::v1i64";
+  case MVT::v2i64: return "MVT::v2i64";
+  case MVT::v4i64: return "MVT::v4i64";
+  case MVT::v2f32: return "MVT::v2f32";
+  case MVT::v4f32: return "MVT::v4f32";
+  case MVT::v8f32: return "MVT::v8f32";
+  case MVT::v2f64: return "MVT::v2f64";
+  case MVT::v4f64: return "MVT::v4f64";
+  case MVT::Metadata: return "MVT::Metadata";
+  case MVT::iPTR:  return "MVT::iPTR";
+  case MVT::iPTRAny:  return "MVT::iPTRAny";
   default: assert(0 && "ILLEGAL VALUE TYPE!"); return "";
   }
 }
@@ -191,7 +191,7 @@ std::vector<unsigned char> CodeGenTarget::getRegisterVTs(Record *R) const {
     const CodeGenRegisterClass &RC = RegisterClasses[i];
     for (unsigned ei = 0, ee = RC.Elements.size(); ei != ee; ++ei) {
       if (R == RC.Elements[ei]) {
-        const std::vector<EVT::SimpleValueType> &InVTs = RC.getValueTypes();
+        const std::vector<MVT::SimpleValueType> &InVTs = RC.getValueTypes();
         for (unsigned i = 0, e = InVTs.size(); i != e; ++i)
           Result.push_back(InVTs[i]);
       }
@@ -477,12 +477,12 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
   }
   
   // Parse the list of return types.
-  std::vector<EVT::SimpleValueType> OverloadedVTs;
+  std::vector<MVT::SimpleValueType> OverloadedVTs;
   ListInit *TypeList = R->getValueAsListInit("RetTypes");
   for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
     Record *TyEl = TypeList->getElementAsRecord(i);
     assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
-    EVT::SimpleValueType VT;
+    MVT::SimpleValueType VT;
     if (TyEl->isSubClassOf("LLVMMatchType")) {
       unsigned MatchTy = TyEl->getValueAsInt("Number");
       assert(MatchTy < OverloadedVTs.size() &&
@@ -493,7 +493,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
       // overloaded, all the types can be specified directly.
       assert(((!TyEl->isSubClassOf("LLVMExtendedElementVectorType") &&
                !TyEl->isSubClassOf("LLVMTruncatedElementVectorType")) ||
-              VT == EVT::iAny || VT == EVT::vAny) &&
+              VT == MVT::iAny || VT == MVT::vAny) &&
              "Expected iAny or vAny type");
     } else {
       VT = getValueType(TyEl->getValueAsDef("VT"));
@@ -514,7 +514,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
   for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
     Record *TyEl = TypeList->getElementAsRecord(i);
     assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
-    EVT::SimpleValueType VT;
+    MVT::SimpleValueType VT;
     if (TyEl->isSubClassOf("LLVMMatchType")) {
       unsigned MatchTy = TyEl->getValueAsInt("Number");
       assert(MatchTy < OverloadedVTs.size() &&
@@ -525,7 +525,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
       // overloaded, all the types can be specified directly.
       assert(((!TyEl->isSubClassOf("LLVMExtendedElementVectorType") &&
                !TyEl->isSubClassOf("LLVMTruncatedElementVectorType")) ||
-              VT == EVT::iAny || VT == EVT::vAny) &&
+              VT == MVT::iAny || VT == MVT::vAny) &&
              "Expected iAny or vAny type");
     } else
       VT = getValueType(TyEl->getValueAsDef("VT"));
diff --git a/utils/TableGen/CodeGenTarget.h b/utils/TableGen/CodeGenTarget.h
index d18df4f9c5..e763795ce0 100644
--- a/utils/TableGen/CodeGenTarget.h
+++ b/utils/TableGen/CodeGenTarget.h
@@ -49,12 +49,12 @@ enum SDNP {
 // ComplexPattern attributes.
 enum CPAttr { CPAttrParentAsRoot };
 
-/// getValueType - Return the EVT::SimpleValueType that the specified TableGen
+/// getValueType - Return the MVT::SimpleValueType that the specified TableGen
 /// record corresponds to.
-EVT::SimpleValueType getValueType(Record *Rec);
+MVT::SimpleValueType getValueType(Record *Rec);
 
-std::string getName(EVT::SimpleValueType T);
-std::string getEnumName(EVT::SimpleValueType T);
+std::string getName(MVT::SimpleValueType T);
+std::string getEnumName(MVT::SimpleValueType T);
 
 /// getQualifiedName - Return the name of the specified record, with a
 /// namespace qualifier if the record contains one.
@@ -68,7 +68,7 @@ class CodeGenTarget {
   mutable std::map<std::string, CodeGenInstruction> Instructions;
   mutable std::vector<CodeGenRegister> Registers;
   mutable std::vector<CodeGenRegisterClass> RegisterClasses;
-  mutable std::vector<EVT::SimpleValueType> LegalValueTypes;
+  mutable std::vector<MVT::SimpleValueType> LegalValueTypes;
   void ReadRegisters() const;
   void ReadRegisterClasses() const;
   void ReadInstructions() const;
@@ -172,15 +172,15 @@ public:
   /// specified physical register.
   std::vector<unsigned char> getRegisterVTs(Record *R) const;
   
-  const std::vector<EVT::SimpleValueType> &getLegalValueTypes() const {
+  const std::vector<MVT::SimpleValueType> &getLegalValueTypes() const {
     if (LegalValueTypes.empty()) ReadLegalValueTypes();
     return LegalValueTypes;
   }
   
   /// isLegalValueType - Return true if the specified value type is natively
   /// supported by the target (i.e. there are registers that directly hold it).
-  bool isLegalValueType(EVT::SimpleValueType VT) const {
-    const std::vector<EVT::SimpleValueType> &LegalVTs = getLegalValueTypes();
+  bool isLegalValueType(MVT::SimpleValueType VT) const {
+    const std::vector<MVT::SimpleValueType> &LegalVTs = getLegalValueTypes();
     for (unsigned i = 0, e = LegalVTs.size(); i != e; ++i)
       if (LegalVTs[i] == VT) return true;
     return false;    
@@ -222,7 +222,7 @@ public:
 /// ComplexPattern - ComplexPattern info, corresponding to the ComplexPattern
 /// tablegen class in TargetSelectionDAG.td
 class ComplexPattern {
-  EVT::SimpleValueType Ty;
+  MVT::SimpleValueType Ty;
   unsigned NumOperands;
   std::string SelectFunc;
   std::vector<Record*> RootNodes;
@@ -232,7 +232,7 @@ public:
   ComplexPattern() : NumOperands(0) {};
   ComplexPattern(Record *R);
 
-  EVT::SimpleValueType getValueType() const { return Ty; }
+  MVT::SimpleValueType getValueType() const { return Ty; }
   unsigned getNumOperands() const { return NumOperands; }
   const std::string &getSelectFunc() const { return SelectFunc; }
   const std::vector<Record*> &getRootNodes() const {
diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp
index 4bdb4d953e..b116aa20c3 100644
--- a/utils/TableGen/DAGISelEmitter.cpp
+++ b/utils/TableGen/DAGISelEmitter.cpp
@@ -59,10 +59,10 @@ static const ComplexPattern *NodeGetComplexPattern(TreePatternNode *N,
 static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) {
   assert((EEVT::isExtIntegerInVTs(P->getExtTypes()) ||
           EEVT::isExtFloatingPointInVTs(P->getExtTypes()) ||
-          P->getExtTypeNum(0) == EVT::isVoid ||
-          P->getExtTypeNum(0) == EVT::Flag ||
-          P->getExtTypeNum(0) == EVT::iPTR ||
-          P->getExtTypeNum(0) == EVT::iPTRAny) && 
+          P->getExtTypeNum(0) == MVT::isVoid ||
+          P->getExtTypeNum(0) == MVT::Flag ||
+          P->getExtTypeNum(0) == MVT::iPTR ||
+          P->getExtTypeNum(0) == MVT::iPTRAny) && 
          "Not a valid pattern node to size!");
   unsigned Size = 3;  // The node itself.
   // If the root node is a ConstantSDNode, increases its size.
@@ -87,7 +87,7 @@ static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) {
   // Count children in the count if they are also nodes.
   for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) {
     TreePatternNode *Child = P->getChild(i);
-    if (!Child->isLeaf() && Child->getExtTypeNum(0) != EVT::Other)
+    if (!Child->isLeaf() && Child->getExtTypeNum(0) != MVT::Other)
       Size += getPatternSize(Child, CGP);
     else if (Child->isLeaf()) {
       if (dynamic_cast<IntInit*>(Child->getLeafValue())) 
@@ -174,10 +174,10 @@ struct PatternSortingPredicate {
 
 /// getRegisterValueType - Look up and return the ValueType of the specified
 /// register. If the register is a member of multiple register classes which
-/// have different associated types, return EVT::Other.
-static EVT::SimpleValueType getRegisterValueType(Record *R, const CodeGenTarget &T) {
+/// have different associated types, return MVT::Other.
+static MVT::SimpleValueType getRegisterValueType(Record *R, const CodeGenTarget &T) {
   bool FoundRC = false;
-  EVT::SimpleValueType VT = EVT::Other;
+  MVT::SimpleValueType VT = MVT::Other;
   const std::vector<CodeGenRegisterClass> &RCs = T.getRegisterClasses();
   std::vector<CodeGenRegisterClass>::const_iterator RC;
   std::vector<Record*>::const_iterator Element;
@@ -191,9 +191,9 @@ static EVT::SimpleValueType getRegisterValueType(Record *R, const CodeGenTarget
       } else {
         // In multiple RC's
         if (VT != (*RC).getValueTypeNum(0)) {
-          // Types of the RC's do not agree. Return EVT::Other. The
+          // Types of the RC's do not agree. Return MVT::Other. The
           // target is responsible for handling this.
-          return EVT::Other;
+          return MVT::Other;
         }
       }
     }
@@ -740,7 +740,7 @@ public:
         } else if (LeafRec->isSubClassOf("ValueType")) {
           // Make sure this is the specified value type.
           emitCheck("cast<VTSDNode>(" + RootName +
-                    ")->getVT() == EVT::" + LeafRec->getName());
+                    ")->getVT() == MVT::" + LeafRec->getName());
         } else if (LeafRec->isSubClassOf("CondCode")) {
           // Make sure this is the specified cond code.
           emitCheck("cast<CondCodeSDNode>(" + RootName +
@@ -813,11 +813,11 @@ public:
           errs() << "Cannot handle " << getEnumName(N->getTypeNum(0))
                << " type as an immediate constant. Aborting\n";
           abort();
-        case EVT::i1:  CastType = "bool"; break;
-        case EVT::i8:  CastType = "unsigned char"; break;
-        case EVT::i16: CastType = "unsigned short"; break;
-        case EVT::i32: CastType = "unsigned"; break;
-        case EVT::i64: CastType = "uint64_t"; break;
+        case MVT::i1:  CastType = "bool"; break;
+        case MVT::i8:  CastType = "unsigned char"; break;
+        case MVT::i16: CastType = "unsigned short"; break;
+        case MVT::i32: CastType = "unsigned"; break;
+        case MVT::i64: CastType = "uint64_t"; break;
         }
         emitCode("SDValue " + TmpVar + 
                  " = CurDAG->getTargetConstant(((" + CastType +
@@ -921,7 +921,7 @@ public:
           emitCode("SDValue Tmp" + utostr(ResNo) +
                    " = CurDAG->getTargetConstant(" +
                    getQualifiedName(DI->getDef()) + "RegClassID, " +
-                   "EVT::i32);");
+                   "MVT::i32);");
           NodeOps.push_back("Tmp" + utostr(ResNo));
           return NodeOps;
         }
@@ -979,7 +979,7 @@ public:
 
       if (NodeHasOptInFlag) {
         emitCode("bool HasInFlag = "
-           "(N.getOperand(N.getNumOperands()-1).getValueType() == EVT::Flag);");
+           "(N.getOperand(N.getNumOperands()-1).getValueType() == MVT::Flag);");
       }
       if (IsVariadic)
         emitCode("SmallVector<SDValue, 8> Ops" + utostr(OpcNo) + ";");
@@ -987,8 +987,8 @@ public:
       // How many results is this pattern expected to produce?
       unsigned NumPatResults = 0;
       for (unsigned i = 0, e = Pattern->getExtTypes().size(); i != e; i++) {
-        EVT::SimpleValueType VT = Pattern->getTypeNum(i);
-        if (VT != EVT::isVoid && VT != EVT::Flag)
+        MVT::SimpleValueType VT = Pattern->getTypeNum(i);
+        if (VT != MVT::isVoid && VT != MVT::Flag)
           NumPatResults++;
       }
 
@@ -1007,7 +1007,7 @@ public:
         }
         emitCode("InChains.push_back(" + ChainName + ");");
         emitCode(ChainName + " = CurDAG->getNode(ISD::TokenFactor, "
-                 "N.getDebugLoc(), EVT::Other, "
+                 "N.getDebugLoc(), MVT::Other, "
                  "&InChains[0], InChains.size());");
         if (GenDebug) {
           emitCode("CurDAG->setSubgraphColor(" + ChainName +".getNode(), \"yellow\");");
@@ -1096,7 +1096,7 @@ public:
 
       // Output order: results, chain, flags
       // Result types.
-      if (NumResults > 0 && N->getTypeNum(0) != EVT::isVoid) {
+      if (NumResults > 0 && N->getTypeNum(0) != MVT::isVoid) {
         Code += ", VT" + utostr(VTNo);
         emitVT(getEnumName(N->getTypeNum(0)));
       }
@@ -1105,14 +1105,14 @@ public:
       for (unsigned i = 0; i < NumDstRegs; i++) {
         Record *RR = DstRegs[i];
         if (RR->isSubClassOf("Register")) {
-          EVT::SimpleValueType RVT = getRegisterValueType(RR, CGT);
+          MVT::SimpleValueType RVT = getRegisterValueType(RR, CGT);
           Code += ", " + getEnumName(RVT);
         }
       }
       if (NodeHasChain)
-        Code += ", EVT::Other";
+        Code += ", MVT::Other";
       if (NodeHasOutFlag)
-        Code += ", EVT::Flag";
+        Code += ", MVT::Flag";
 
       // Inputs.
       if (IsVariadic) {
@@ -1405,8 +1405,8 @@ private:
 
           Record *RR = DI->getDef();
           if (RR->isSubClassOf("Register")) {
-            EVT::SimpleValueType RVT = getRegisterValueType(RR, T);
-            if (RVT == EVT::Flag) {
+            MVT::SimpleValueType RVT = getRegisterValueType(RR, T);
+            if (RVT == MVT::Flag) {
               if (!InFlagDecled) {
                 emitCode("SDValue InFlag = " + RootName + utostr(OpNo) + ";");
                 InFlagDecled = true;
@@ -1707,7 +1707,7 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
     assert(!PatternsOfOp.empty() && "No patterns but map has entry?");
 
     // Split them into groups by type.
-    std::map<EVT::SimpleValueType,
+    std::map<MVT::SimpleValueType,
              std::vector<const PatternToMatch*> > PatternsByType;
     for (unsigned i = 0, e = PatternsOfOp.size(); i != e; ++i) {
       const PatternToMatch *Pat = PatternsOfOp[i];
@@ -1715,11 +1715,11 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
       PatternsByType[SrcPat->getTypeNum(0)].push_back(Pat);
     }
 
-    for (std::map<EVT::SimpleValueType,
+    for (std::map<MVT::SimpleValueType,
                   std::vector<const PatternToMatch*> >::iterator
            II = PatternsByType.begin(), EE = PatternsByType.end(); II != EE;
          ++II) {
-      EVT::SimpleValueType OpVT = II->first;
+      MVT::SimpleValueType OpVT = II->first;
       std::vector<const PatternToMatch*> &Patterns = II->second;
       typedef std::pair<unsigned, std::string> CodeLine;
       typedef std::vector<CodeLine> CodeList;
@@ -1839,16 +1839,16 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
 
       // Print function.
       std::string OpVTStr;
-      if (OpVT == EVT::iPTR) {
+      if (OpVT == MVT::iPTR) {
         OpVTStr = "_iPTR";
-      } else if (OpVT == EVT::iPTRAny) {
+      } else if (OpVT == MVT::iPTRAny) {
         OpVTStr = "_iPTRAny";
-      } else if (OpVT == EVT::isVoid) {
+      } else if (OpVT == MVT::isVoid) {
         // Nodes with a void result actually have a first result type of either
         // Other (a chain) or Flag.  Since there is no one-to-one mapping from
         // void to this case, we handle it specially here.
       } else {
-        OpVTStr = "_" + getEnumName(OpVT).substr(5);  // Skip 'EVT::'
+        OpVTStr = "_" + getEnumName(OpVT).substr(5);  // Skip 'MVT::'
       }
       std::map<std::string, std::vector<std::string> >::iterator OpVTI =
         OpcodeVTMap.find(OpName);
@@ -1929,8 +1929,8 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
      << "  SelectInlineAsmMemoryOperands(Ops);\n\n"
     
      << "  std::vector<EVT> VTs;\n"
-     << "  VTs.push_back(EVT::Other);\n"
-     << "  VTs.push_back(EVT::Flag);\n"
+     << "  VTs.push_back(MVT::Other);\n"
+     << "  VTs.push_back(MVT::Flag);\n"
      << "  SDValue New = CurDAG->getNode(ISD::INLINEASM, N.getDebugLoc(), "
                  "VTs, &Ops[0], Ops.size());\n"
      << "  return New.getNode();\n"
@@ -1944,17 +1944,17 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
   OS << "SDNode *Select_DBG_LABEL(const SDValue &N) {\n"
      << "  SDValue Chain = N.getOperand(0);\n"
      << "  unsigned C = cast<LabelSDNode>(N)->getLabelID();\n"
-     << "  SDValue Tmp = CurDAG->getTargetConstant(C, EVT::i32);\n"
+     << "  SDValue Tmp = CurDAG->getTargetConstant(C, MVT::i32);\n"
      << "  return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::DBG_LABEL,\n"
-     << "                              EVT::Other, Tmp, Chain);\n"
+     << "                              MVT::Other, Tmp, Chain);\n"
      << "}\n\n";
 
   OS << "SDNode *Select_EH_LABEL(const SDValue &N) {\n"
      << "  SDValue Chain = N.getOperand(0);\n"
      << "  unsigned C = cast<LabelSDNode>(N)->getLabelID();\n"
-     << "  SDValue Tmp = CurDAG->getTargetConstant(C, EVT::i32);\n"
+     << "  SDValue Tmp = CurDAG->getTargetConstant(C, MVT::i32);\n"
      << "  return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::EH_LABEL,\n"
-     << "                              EVT::Other, Tmp, Chain);\n"
+     << "                              MVT::Other, Tmp, Chain);\n"
      << "}\n\n";
 
   OS << "SDNode *Select_DECLARE(const SDValue &N) {\n"
@@ -1971,12 +1971,12 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
      << "  SDValue Tmp2 = "
      << "CurDAG->getTargetGlobalAddress(GV, TLI.getPointerTy());\n"
      << "  return CurDAG->SelectNodeTo(N.getNode(), TargetInstrInfo::DECLARE,\n"
-     << "                              EVT::Other, Tmp1, Tmp2, Chain);\n"
+     << "                              MVT::Other, Tmp1, Tmp2, Chain);\n"
      << "}\n\n";
 
   OS << "// The main instruction selector code.\n"
      << "SDNode *SelectCode(SDValue N) {\n"
-     << "  EVT::SimpleValueType NVT = N.getNode()->getValueType(0).getSimpleVT();\n"
+     << "  MVT::SimpleValueType NVT = N.getNode()->getValueType(0).getSimpleVT().SimpleTy;\n"
      << "  switch (N.getOpcode()) {\n"
      << "  default:\n"
      << "    assert(!N.isMachineOpcode() && \"Node already selected!\");\n"
@@ -2049,7 +2049,7 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
         HasPtrPattern = true;
         continue;
       }
-      OS << "    case EVT::" << VTStr.substr(1) << ":\n"
+      OS << "    case MVT::" << VTStr.substr(1) << ":\n"
          << "      return Select_" << getLegalCName(OpName)
          << VTStr << "(N);\n";
     }
@@ -2091,7 +2091,7 @@ void DAGISelEmitter::EmitInstructionSelector(raw_ostream &OS) {
   OS << "void CannotYetSelectIntrinsic(SDValue N) DISABLE_INLINE {\n"
      << "  cerr << \"Cannot yet select: \";\n"
      << "  unsigned iid = cast<ConstantSDNode>(N.getOperand("
-     << "N.getOperand(0).getValueType() == EVT::Other))->getZExtValue();\n"
+     << "N.getOperand(0).getValueType() == MVT::Other))->getZExtValue();\n"
      << " llvm_report_error(\"Cannot yet select: intrinsic %\" +\n"
      << "Intrinsic::getName((Intrinsic::ID)iid));\n"
      << "}\n\n";
diff --git a/utils/TableGen/FastISelEmitter.cpp b/utils/TableGen/FastISelEmitter.cpp
index e955675026..bf92a9a023 100644
--- a/utils/TableGen/FastISelEmitter.cpp
+++ b/utils/TableGen/FastISelEmitter.cpp
@@ -53,7 +53,7 @@ struct OperandsSignature {
   ///
   bool initialize(TreePatternNode *InstPatNode,
                   const CodeGenTarget &Target,
-                  EVT::SimpleValueType VT) {
+                  MVT::SimpleValueType VT) {
     if (!InstPatNode->isLeaf() &&
         InstPatNode->getOperator()->getName() == "imm") {
       Operands.push_back("i");
@@ -203,8 +203,8 @@ struct OperandsSignature {
 
 class FastISelMap {
   typedef std::map<std::string, InstructionMemo> PredMap;
-  typedef std::map<EVT::SimpleValueType, PredMap> RetPredMap;
-  typedef std::map<EVT::SimpleValueType, RetPredMap> TypeRetPredMap;
+  typedef std::map<MVT::SimpleValueType, PredMap> RetPredMap;
+  typedef std::map<MVT::SimpleValueType, RetPredMap> TypeRetPredMap;
   typedef std::map<std::string, TypeRetPredMap> OpcodeTypeRetPredMap;
   typedef std::map<OperandsSignature, OpcodeTypeRetPredMap> OperandsOpcodeTypeRetPredMap;
 
@@ -297,8 +297,8 @@ void FastISelMap::CollectPatterns(CodeGenDAGPatterns &CGP) {
 
     Record *InstPatOp = InstPatNode->getOperator();
     std::string OpcodeName = getOpcodeName(InstPatOp, CGP);
-    EVT::SimpleValueType RetVT = InstPatNode->getTypeNum(0);
-    EVT::SimpleValueType VT = RetVT;
+    MVT::SimpleValueType RetVT = InstPatNode->getTypeNum(0);
+    MVT::SimpleValueType VT = RetVT;
     if (InstPatNode->getNumChildren())
       VT = InstPatNode->getChild(0)->getTypeNum(0);
 
@@ -385,12 +385,12 @@ void FastISelMap::PrintFunctionDefinitions(raw_ostream &OS) {
       // Emit one function for each opcode,type pair.
       for (TypeRetPredMap::const_iterator TI = TM.begin(), TE = TM.end();
            TI != TE; ++TI) {
-        EVT::SimpleValueType VT = TI->first;
+        MVT::SimpleValueType VT = TI->first;
         const RetPredMap &RM = TI->second;
         if (RM.size() != 1) {
           for (RetPredMap::const_iterator RI = RM.begin(), RE = RM.end();
                RI != RE; ++RI) {
-            EVT::SimpleValueType RetVT = RI->first;
+            MVT::SimpleValueType RetVT = RI->first;
             const PredMap &PM = RI->second;
             bool HasPred = false;
 
@@ -461,14 +461,14 @@ void FastISelMap::PrintFunctionDefinitions(raw_ostream &OS) {
              << getLegalCName(Opcode) << "_"
              << getLegalCName(getName(VT)) << "_";
           Operands.PrintManglingSuffix(OS);
-          OS << "(EVT::SimpleValueType RetVT";
+          OS << "(MVT RetVT";
           if (!Operands.empty())
             OS << ", ";
           Operands.PrintParameters(OS);
-          OS << ") {\nswitch (RetVT) {\n";
+          OS << ") {\nswitch (RetVT.SimpleTy) {\n";
           for (RetPredMap::const_iterator RI = RM.begin(), RE = RM.end();
                RI != RE; ++RI) {
-            EVT::SimpleValueType RetVT = RI->first;
+            MVT::SimpleValueType RetVT = RI->first;
             OS << "  case " << getName(RetVT) << ": return FastEmit_"
                << getLegalCName(Opcode) << "_" << getLegalCName(getName(VT))
                << "_" << getLegalCName(getName(RetVT)) << "_";
@@ -485,13 +485,13 @@ void FastISelMap::PrintFunctionDefinitions(raw_ostream &OS) {
              << getLegalCName(Opcode) << "_"
              << getLegalCName(getName(VT)) << "_";
           Operands.PrintManglingSuffix(OS);
-          OS << "(EVT::SimpleValueType RetVT";
+          OS << "(MVT RetVT";
           if (!Operands.empty())
             OS << ", ";
           Operands.PrintParameters(OS);
           OS << ") {\n";
           
-          OS << "  if (RetVT != " << getName(RM.begin()->first)
+          OS << "  if (RetVT.SimpleTy != " << getName(RM.begin()->first)
              << ")\n    return 0;\n";
           
           const PredMap &PM = RM.begin()->second;
@@ -555,15 +555,15 @@ void FastISelMap::PrintFunctionDefinitions(raw_ostream &OS) {
       OS << "unsigned FastEmit_"
          << getLegalCName(Opcode) << "_";
       Operands.PrintManglingSuffix(OS);
-      OS << "(EVT::SimpleValueType VT, EVT::SimpleValueType RetVT";
+      OS << "(MVT VT, MVT RetVT";
       if (!Operands.empty())
         OS << ", ";
       Operands.PrintParameters(OS);
       OS << ") {\n";
-      OS << "  switch (VT) {\n";
+      OS << "  switch (VT.SimpleTy) {\n";
       for (TypeRetPredMap::const_iterator TI = TM.begin(), TE = TM.end();
            TI != TE; ++TI) {
-        EVT::SimpleValueType VT = TI->first;
+        MVT::SimpleValueType VT = TI->first;
         std::string TypeName = getName(VT);
         OS << "  case " << TypeName << ": return FastEmit_"
            << getLegalCName(Opcode) << "_" << getLegalCName(TypeName) << "_";
@@ -587,7 +587,7 @@ void FastISelMap::PrintFunctionDefinitions(raw_ostream &OS) {
     // on opcode and type.
     OS << "unsigned FastEmit_";
     Operands.PrintManglingSuffix(OS);
-    OS << "(EVT::SimpleValueType VT, EVT::SimpleValueType RetVT, ISD::NodeType Opcode";
+    OS << "(MVT VT, MVT RetVT, ISD::NodeType Opcode";
     if (!Operands.empty())
       OS << ", ";
     Operands.PrintParameters(OS);
diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 79874b1629..1497e9029d 100644
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -140,26 +140,26 @@ EmitIntrinsicToOverloadTable(const std::vector<CodeGenIntrinsic> &Ints,
   OS << "#endif\n\n";
 }
 
-static void EmitTypeForValueType(raw_ostream &OS, EVT::SimpleValueType VT) {
+static void EmitTypeForValueType(raw_ostream &OS, MVT::SimpleValueType VT) {
   if (EVT(VT).isInteger()) {
     unsigned BitWidth = EVT(VT).getSizeInBits();
     OS << "IntegerType::get(" << BitWidth << ")";
-  } else if (VT == EVT::Other) {
-    // EVT::OtherVT is used to mean the empty struct type here.
+  } else if (VT == MVT::Other) {
+    // MVT::OtherVT is used to mean the empty struct type here.
     OS << "StructType::get(Context)";
-  } else if (VT == EVT::f32) {
+  } else if (VT == MVT::f32) {
     OS << "Type::FloatTy";
-  } else if (VT == EVT::f64) {
+  } else if (VT == MVT::f64) {
     OS << "Type::DoubleTy";
-  } else if (VT == EVT::f80) {
+  } else if (VT == MVT::f80) {
     OS << "Type::X86_FP80Ty";
-  } else if (VT == EVT::f128) {
+  } else if (VT == MVT::f128) {
     OS << "Type::FP128Ty";
-  } else if (VT == EVT::ppcf128) {
+  } else if (VT == MVT::ppcf128) {
     OS << "Type::PPC_FP128Ty";
-  } else if (VT == EVT::isVoid) {
+  } else if (VT == MVT::isVoid) {
     OS << "Type::VoidTy";
-  } else if (VT == EVT::Metadata) {
+  } else if (VT == MVT::Metadata) {
     OS << "Type::MetadataTy";
   } else {
     assert(false && "Unsupported ValueType!");
@@ -190,7 +190,7 @@ static void EmitTypeGenerate(raw_ostream &OS,
 
 static void EmitTypeGenerate(raw_ostream &OS, const Record *ArgType,
                              unsigned &ArgNo) {
-  EVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
+  MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
 
   if (ArgType->isSubClassOf("LLVMMatchType")) {
     unsigned Number = ArgType->getValueAsInt("Number");
@@ -203,7 +203,7 @@ static void EmitTypeGenerate(raw_ostream &OS, const Record *ArgType,
          << "(dyn_cast<VectorType>(Tys[" << Number << "]))";
     else
       OS << "Tys[" << Number << "]";
-  } else if (VT == EVT::iAny || VT == EVT::fAny || VT == EVT::vAny) {
+  } else if (VT == MVT::iAny || VT == MVT::fAny || VT == MVT::vAny) {
     // NOTE: The ArgNo variable here is not the absolute argument number, it is
     // the index of the "arbitrary" type in the Tys array passed to the
     // Intrinsic::getDeclaration function. Consequently, we only want to
@@ -213,13 +213,13 @@ static void EmitTypeGenerate(raw_ostream &OS, const Record *ArgType,
   } else if (EVT(VT).isVector()) {
     EVT VVT = VT;
     OS << "VectorType::get(";
-    EmitTypeForValueType(OS, VVT.getVectorElementType().getSimpleVT());
+    EmitTypeForValueType(OS, VVT.getVectorElementType().getSimpleVT().SimpleTy);
     OS << ", " << VVT.getVectorNumElements() << ")";
-  } else if (VT == EVT::iPTR) {
+  } else if (VT == MVT::iPTR) {
     OS << "PointerType::getUnqual(";
     EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
     OS << ")";
-  } else if (VT == EVT::iPTRAny) {
+  } else if (VT == MVT::iPTRAny) {
     // Make sure the user has passed us an argument type to overload. If not,
     // treat it as an ordinary (not overloaded) intrinsic.
     OS << "(" << ArgNo << " < numTys) ? Tys[" << ArgNo 
@@ -227,11 +227,11 @@ static void EmitTypeGenerate(raw_ostream &OS, const Record *ArgType,
     EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
     OS << ")";
     ++ArgNo;
-  } else if (VT == EVT::isVoid) {
+  } else if (VT == MVT::isVoid) {
     if (ArgNo == 0)
       OS << "Type::VoidTy";
     else
-      // EVT::isVoid is used to mean varargs here.
+      // MVT::isVoid is used to mean varargs here.
       OS << "...";
   } else {
     EmitTypeForValueType(OS, VT);
@@ -326,13 +326,13 @@ void IntrinsicEmitter::EmitVerifier(const std::vector<CodeGenIntrinsic> &Ints,
         else
           OS << "~" << Number;
       } else {
-        EVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
+        MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
         OS << getEnumName(VT);
 
         if (EVT(VT).isOverloaded())
           OverloadedTypeIndices.push_back(j);
 
-        if (VT == EVT::isVoid && j != 0 && j != je - 1)
+        if (VT == MVT::isVoid && j != 0 && j != je - 1)
           throw "Var arg type not last argument";
       }
     }
@@ -354,13 +354,13 @@ void IntrinsicEmitter::EmitVerifier(const std::vector<CodeGenIntrinsic> &Ints,
         else
           OS << "~" << Number;
       } else {
-        EVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
+        MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT"));
         OS << getEnumName(VT);
 
         if (EVT(VT).isOverloaded())
           OverloadedTypeIndices.push_back(j + RetTys.size());
 
-        if (VT == EVT::isVoid && j != 0 && j != je - 1)
+        if (VT == MVT::isVoid && j != 0 && j != je - 1)
           throw "Var arg type not last argument";
       }
     }
@@ -405,7 +405,7 @@ void IntrinsicEmitter::EmitGenerator(const std::vector<CodeGenIntrinsic> &Ints,
     unsigned N = ParamTys.size();
 
     if (N > 1 &&
-        getValueType(ParamTys[N - 1]->getValueAsDef("VT")) == EVT::isVoid) {
+        getValueType(ParamTys[N - 1]->getValueAsDef("VT")) == MVT::isVoid) {
       OS << "    IsVarArg = true;\n";
       --N;
     }
diff --git a/utils/TableGen/RegisterInfoEmitter.cpp b/utils/TableGen/RegisterInfoEmitter.cpp
index 41ed56bd12..a9bb2a13e3 100644
--- a/utils/TableGen/RegisterInfoEmitter.cpp
+++ b/utils/TableGen/RegisterInfoEmitter.cpp
@@ -226,7 +226,7 @@ void RegisterInfoEmitter::run(raw_ostream &OS) {
        << "[] = {\n    ";
     for (unsigned i = 0, e = RC.VTs.size(); i != e; ++i)
       OS << getEnumName(RC.VTs[i]) << ", ";
-    OS << "EVT::Other\n  };\n\n";
+    OS << "MVT::Other\n  };\n\n";
   }
   OS << "}  // end anonymous namespace\n\n";