Rename MVT to EVT, in preparation for splitting SimpleValueType out into its own struct type.

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

2 files changed, 201 insertions, 201 deletions

diff --git a/lib/Target/PIC16/PIC16ISelLowering.cpp b/lib/Target/PIC16/PIC16ISelLowering.cpp
index a98604b..72cc1e2 100644
--- a/lib/Target/PIC16/PIC16ISelLowering.cpp
+++ b/lib/Target/PIC16/PIC16ISelLowering.cpp
@@ -147,9 +147,9 @@ PIC16TargetLowering::PIC16TargetLowering(PIC16TargetMachine &TM)
  
   Subtarget = &TM.getSubtarget<PIC16Subtarget>();
 
-  addRegisterClass(MVT::i8, PIC16::GPRRegisterClass);
+  addRegisterClass(EVT::i8, PIC16::GPRRegisterClass);
 
-  setShiftAmountType(MVT::i8);
+  setShiftAmountType(EVT::i8);
   
   // Std lib call names
   setLibcallName(RTLIB::COS_F32, getStdLibCallName(RTLIB::COS_F32));
@@ -243,65 +243,65 @@ PIC16TargetLowering::PIC16TargetLowering(PIC16TargetMachine &TM)
   setCmpLibcallCC(RTLIB::UO_F32, ISD::SETNE);
   setCmpLibcallCC(RTLIB::O_F32, ISD::SETEQ);
 
-  setOperationAction(ISD::GlobalAddress, MVT::i16, Custom);
-  setOperationAction(ISD::ExternalSymbol, MVT::i16, Custom);
+  setOperationAction(ISD::GlobalAddress, EVT::i16, Custom);
+  setOperationAction(ISD::ExternalSymbol, EVT::i16, Custom);
 
-  setOperationAction(ISD::LOAD,   MVT::i8,  Legal);
-  setOperationAction(ISD::LOAD,   MVT::i16, Custom);
-  setOperationAction(ISD::LOAD,   MVT::i32, Custom);
+  setOperationAction(ISD::LOAD,   EVT::i8,  Legal);
+  setOperationAction(ISD::LOAD,   EVT::i16, Custom);
+  setOperationAction(ISD::LOAD,   EVT::i32, Custom);
 
-  setOperationAction(ISD::STORE,  MVT::i8,  Legal);
-  setOperationAction(ISD::STORE,  MVT::i16, Custom);
-  setOperationAction(ISD::STORE,  MVT::i32, Custom);
-  setOperationAction(ISD::STORE,  MVT::i64, Custom);
+  setOperationAction(ISD::STORE,  EVT::i8,  Legal);
+  setOperationAction(ISD::STORE,  EVT::i16, Custom);
+  setOperationAction(ISD::STORE,  EVT::i32, Custom);
+  setOperationAction(ISD::STORE,  EVT::i64, Custom);
 
-  setOperationAction(ISD::ADDE,    MVT::i8,  Custom);
-  setOperationAction(ISD::ADDC,    MVT::i8,  Custom);
-  setOperationAction(ISD::SUBE,    MVT::i8,  Custom);
-  setOperationAction(ISD::SUBC,    MVT::i8,  Custom);
-  setOperationAction(ISD::SUB,    MVT::i8,  Custom);
-  setOperationAction(ISD::ADD,    MVT::i8,  Custom);
-  setOperationAction(ISD::ADD,    MVT::i16, Custom);
+  setOperationAction(ISD::ADDE,    EVT::i8,  Custom);
+  setOperationAction(ISD::ADDC,    EVT::i8,  Custom);
+  setOperationAction(ISD::SUBE,    EVT::i8,  Custom);
+  setOperationAction(ISD::SUBC,    EVT::i8,  Custom);
+  setOperationAction(ISD::SUB,    EVT::i8,  Custom);
+  setOperationAction(ISD::ADD,    EVT::i8,  Custom);
+  setOperationAction(ISD::ADD,    EVT::i16, Custom);
 
-  setOperationAction(ISD::OR,     MVT::i8,  Custom);
-  setOperationAction(ISD::AND,    MVT::i8,  Custom);
-  setOperationAction(ISD::XOR,    MVT::i8,  Custom);
+  setOperationAction(ISD::OR,     EVT::i8,  Custom);
+  setOperationAction(ISD::AND,    EVT::i8,  Custom);
+  setOperationAction(ISD::XOR,    EVT::i8,  Custom);
 
-  setOperationAction(ISD::FrameIndex, MVT::i16, Custom);
+  setOperationAction(ISD::FrameIndex, EVT::i16, Custom);
 
-  setOperationAction(ISD::MUL,    MVT::i8,  Custom);
+  setOperationAction(ISD::MUL,    EVT::i8,  Custom);
 
-  setOperationAction(ISD::SMUL_LOHI,    MVT::i8,  Expand);
-  setOperationAction(ISD::UMUL_LOHI,    MVT::i8,  Expand);
-  setOperationAction(ISD::MULHU,        MVT::i8, Expand);
-  setOperationAction(ISD::MULHS,        MVT::i8, Expand);
+  setOperationAction(ISD::SMUL_LOHI,    EVT::i8,  Expand);
+  setOperationAction(ISD::UMUL_LOHI,    EVT::i8,  Expand);
+  setOperationAction(ISD::MULHU,        EVT::i8, Expand);
+  setOperationAction(ISD::MULHS,        EVT::i8, Expand);
 
-  setOperationAction(ISD::SRA,    MVT::i8,  Custom);
-  setOperationAction(ISD::SHL,    MVT::i8,  Custom);
-  setOperationAction(ISD::SRL,    MVT::i8,  Custom);
+  setOperationAction(ISD::SRA,    EVT::i8,  Custom);
+  setOperationAction(ISD::SHL,    EVT::i8,  Custom);
+  setOperationAction(ISD::SRL,    EVT::i8,  Custom);
 
-  setOperationAction(ISD::ROTL,    MVT::i8,  Expand);
-  setOperationAction(ISD::ROTR,    MVT::i8,  Expand);
+  setOperationAction(ISD::ROTL,    EVT::i8,  Expand);
+  setOperationAction(ISD::ROTR,    EVT::i8,  Expand);
 
-  setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand);
+  setOperationAction(ISD::SIGN_EXTEND_INREG, EVT::i1, Expand);
 
   // PIC16 does not support shift parts
-  setOperationAction(ISD::SRA_PARTS,    MVT::i8, Expand);
-  setOperationAction(ISD::SHL_PARTS,    MVT::i8, Expand);
-  setOperationAction(ISD::SRL_PARTS,    MVT::i8, Expand);
+  setOperationAction(ISD::SRA_PARTS,    EVT::i8, Expand);
+  setOperationAction(ISD::SHL_PARTS,    EVT::i8, Expand);
+  setOperationAction(ISD::SRL_PARTS,    EVT::i8, Expand);
 
 
   // PIC16 does not have a SETCC, expand it to SELECT_CC.
-  setOperationAction(ISD::SETCC,  MVT::i8, Expand);
-  setOperationAction(ISD::SELECT,  MVT::i8, Expand);
-  setOperationAction(ISD::BRCOND, MVT::Other, Expand);
-  setOperationAction(ISD::BRIND, MVT::Other, Expand);
+  setOperationAction(ISD::SETCC,  EVT::i8, Expand);
+  setOperationAction(ISD::SELECT,  EVT::i8, Expand);
+  setOperationAction(ISD::BRCOND, EVT::Other, Expand);
+  setOperationAction(ISD::BRIND, EVT::Other, Expand);
 
-  setOperationAction(ISD::SELECT_CC,  MVT::i8, Custom);
-  setOperationAction(ISD::BR_CC,  MVT::i8, Custom);
+  setOperationAction(ISD::SELECT_CC,  EVT::i8, Custom);
+  setOperationAction(ISD::BR_CC,  EVT::i8, Custom);
 
-  //setOperationAction(ISD::TRUNCATE, MVT::i16, Custom);
-  setTruncStoreAction(MVT::i16,   MVT::i8,  Custom);
+  //setOperationAction(ISD::TRUNCATE, EVT::i16, Custom);
+  setTruncStoreAction(EVT::i16,   EVT::i8,  Custom);
 
   // Now deduce the information based on the above mentioned 
   // actions
@@ -313,7 +313,7 @@ static SDValue getOutFlag(SDValue &Op) {
   // Flag is the last value of the node.
   SDValue Flag = Op.getValue(Op.getNode()->getNumValues() - 1);
 
-  assert (Flag.getValueType() == MVT::Flag 
+  assert (Flag.getValueType() == EVT::Flag 
           && "Node does not have an out Flag");
 
   return Flag;
@@ -340,12 +340,12 @@ static SDValue getChain(SDValue &Op) {
 
   // If the last value returned in Flag then the chain is
   // second last value returned.
-  if (Chain.getValueType() == MVT::Flag)
+  if (Chain.getValueType() == EVT::Flag)
     Chain = Op.getValue(Op.getNode()->getNumValues() - 2);
   
   // All nodes may not produce a chain. Therefore following assert
   // verifies that the node is returning a chain only.
-  assert (Chain.getValueType() == MVT::Other 
+  assert (Chain.getValueType() == EVT::Other 
           && "Node does not have a chain");
 
   return Chain;
@@ -365,9 +365,9 @@ static void PopulateResults(SDValue N, SmallVectorImpl<SDValue>&Results) {
     Results.push_back(N);
 }
 
-MVT::SimpleValueType
-PIC16TargetLowering::getSetCCResultType(MVT ValType) const {
-  return MVT::i8;
+EVT::SimpleValueType
+PIC16TargetLowering::getSetCCResultType(EVT ValType) const {
+  return EVT::i8;
 }
 
 /// The type legalizer framework of generating legalizer can generate libcalls
@@ -389,7 +389,7 @@ PIC16TargetLowering::getPIC16LibcallName(PIC16ISD::PIC16Libcall Call) {
 
 SDValue
 PIC16TargetLowering::MakePIC16Libcall(PIC16ISD::PIC16Libcall Call,
-                                      MVT RetVT, const SDValue *Ops,
+                                      EVT RetVT, const SDValue *Ops,
                                       unsigned NumOps, bool isSigned,
                                       SelectionDAG &DAG, DebugLoc dl) {
 
@@ -399,14 +399,14 @@ PIC16TargetLowering::MakePIC16Libcall(PIC16ISD::PIC16Libcall Call,
   TargetLowering::ArgListEntry Entry;
   for (unsigned i = 0; i != NumOps; ++i) {
     Entry.Node = Ops[i];
-    Entry.Ty = Entry.Node.getValueType().getTypeForMVT();
+    Entry.Ty = Entry.Node.getValueType().getTypeForEVT();
     Entry.isSExt = isSigned;
     Entry.isZExt = !isSigned;
     Args.push_back(Entry);
   }
-  SDValue Callee = DAG.getExternalSymbol(getPIC16LibcallName(Call), MVT::i16);
+  SDValue Callee = DAG.getExternalSymbol(getPIC16LibcallName(Call), EVT::i16);
 
-   const Type *RetTy = RetVT.getTypeForMVT();
+   const Type *RetTy = RetVT.getTypeForEVT();
    std::pair<SDValue,SDValue> CallInfo = 
      LowerCallTo(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
                  false, 0, CallingConv::C, false,
@@ -477,11 +477,11 @@ void PIC16TargetLowering::ReplaceNodeResults(SDNode *N,
 
 SDValue PIC16TargetLowering::ExpandFrameIndex(SDNode *N, SelectionDAG &DAG) {
 
-  // Currently handling FrameIndex of size MVT::i16 only
+  // Currently handling FrameIndex of size EVT::i16 only
   // One example of this scenario is when return value is written on
   // FrameIndex#0
 
-  if (N->getValueType(0) != MVT::i16)
+  if (N->getValueType(0) != EVT::i16)
     return SDValue();
 
   // Expand the FrameIndex into ExternalSymbol and a Constant node
@@ -503,9 +503,9 @@ SDValue PIC16TargetLowering::ExpandFrameIndex(SDNode *N, SelectionDAG &DAG) {
   int FrameOffset;
   SDValue FI = SDValue(N,0);
   LegalizeFrameIndex(FI, DAG, ES, FrameOffset);
-  SDValue Offset = DAG.getConstant(FrameOffset, MVT::i8);
-  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, MVT::i8, ES, Offset);
-  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, MVT::i8, ES, Offset);
+  SDValue Offset = DAG.getConstant(FrameOffset, EVT::i8);
+  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, EVT::i8, ES, Offset);
+  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, EVT::i8, ES, Offset);
   return DAG.getNode(ISD::BUILD_PAIR, dl, N->getValueType(0), Lo, Hi);
 }
 
@@ -515,19 +515,19 @@ SDValue PIC16TargetLowering::ExpandStore(SDNode *N, SelectionDAG &DAG) {
   SDValue Chain = St->getChain();
   SDValue Src = St->getValue();
   SDValue Ptr = St->getBasePtr();
-  MVT ValueType = Src.getValueType();
+  EVT ValueType = Src.getValueType();
   unsigned StoreOffset = 0;
   DebugLoc dl = N->getDebugLoc();
 
   SDValue PtrLo, PtrHi;
   LegalizeAddress(Ptr, DAG, PtrLo, PtrHi, StoreOffset, dl);
  
-  if (ValueType == MVT::i8) {
-    return DAG.getNode (PIC16ISD::PIC16Store, dl, MVT::Other, Chain, Src,
+  if (ValueType == EVT::i8) {
+    return DAG.getNode (PIC16ISD::PIC16Store, dl, EVT::Other, Chain, Src,
                         PtrLo, PtrHi, 
-                        DAG.getConstant (0 + StoreOffset, MVT::i8));
+                        DAG.getConstant (0 + StoreOffset, EVT::i8));
   }
-  else if (ValueType == MVT::i16) {
+  else if (ValueType == EVT::i16) {
     // Get the Lo and Hi parts from MERGE_VALUE or BUILD_PAIR.
     SDValue SrcLo, SrcHi;
     GetExpandedParts(Src, DAG, SrcLo, SrcHi);
@@ -536,19 +536,19 @@ SDValue PIC16TargetLowering::ExpandStore(SDNode *N, SelectionDAG &DAG) {
       ChainLo = Chain.getOperand(0);
       ChainHi = Chain.getOperand(1);
     }
-    SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other,
+    SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other,
                                  ChainLo,
                                  SrcLo, PtrLo, PtrHi,
-                                 DAG.getConstant (0 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (0 + StoreOffset, EVT::i8));
 
-    SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other, ChainHi, 
+    SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other, ChainHi, 
                                  SrcHi, PtrLo, PtrHi,
-                                 DAG.getConstant (1 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (1 + StoreOffset, EVT::i8));
 
-    return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, getChain(Store1),
+    return DAG.getNode(ISD::TokenFactor, dl, EVT::Other, getChain(Store1),
                        getChain(Store2));
   }
-  else if (ValueType == MVT::i32) {
+  else if (ValueType == EVT::i32) {
     // Get the Lo and Hi parts from MERGE_VALUE or BUILD_PAIR.
     SDValue SrcLo, SrcHi;
     GetExpandedParts(Src, DAG, SrcLo, SrcHi);
@@ -573,30 +573,30 @@ SDValue PIC16TargetLowering::ExpandStore(SDNode *N, SelectionDAG &DAG) {
       ChainHi1 = ChainHi.getOperand(0);
       ChainHi2 = ChainHi.getOperand(1);
     }
-    SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other,
+    SDValue Store1 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other,
                                  ChainLo1,
                                  SrcLo1, PtrLo, PtrHi,
-                                 DAG.getConstant (0 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (0 + StoreOffset, EVT::i8));
 
-    SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other, ChainLo2,
+    SDValue Store2 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other, ChainLo2,
                                  SrcLo2, PtrLo, PtrHi,
-                                 DAG.getConstant (1 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (1 + StoreOffset, EVT::i8));
 
-    SDValue Store3 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other, ChainHi1,
+    SDValue Store3 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other, ChainHi1,
                                  SrcHi1, PtrLo, PtrHi,
-                                 DAG.getConstant (2 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (2 + StoreOffset, EVT::i8));
 
-    SDValue Store4 = DAG.getNode(PIC16ISD::PIC16Store, dl, MVT::Other, ChainHi2,
+    SDValue Store4 = DAG.getNode(PIC16ISD::PIC16Store, dl, EVT::Other, ChainHi2,
                                  SrcHi2, PtrLo, PtrHi,
-                                 DAG.getConstant (3 + StoreOffset, MVT::i8));
+                                 DAG.getConstant (3 + StoreOffset, EVT::i8));
 
-    SDValue RetLo =  DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
+    SDValue RetLo =  DAG.getNode(ISD::TokenFactor, dl, EVT::Other, 
                                  getChain(Store1), getChain(Store2));
-    SDValue RetHi =  DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
+    SDValue RetHi =  DAG.getNode(ISD::TokenFactor, dl, EVT::Other, 
                                  getChain(Store3), getChain(Store4));
-    return  DAG.getNode(ISD::TokenFactor, dl, MVT::Other, RetLo, RetHi);
+    return  DAG.getNode(ISD::TokenFactor, dl, EVT::Other, RetLo, RetHi);
 
-  } else if (ValueType == MVT::i64) {
+  } else if (ValueType == EVT::i64) {
     SDValue SrcLo, SrcHi;
     GetExpandedParts(Src, DAG, SrcLo, SrcHi);
     SDValue ChainLo = Chain, ChainHi = Chain;
@@ -612,7 +612,7 @@ SDValue PIC16TargetLowering::ExpandStore(SDNode *N, SelectionDAG &DAG) {
     SDValue Store2 = DAG.getStore(ChainHi, dl, SrcHi, Ptr, NULL,
                                   1 + StoreOffset);
 
-    return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1,
+    return DAG.getNode(ISD::TokenFactor, dl, EVT::Other, Store1,
                        Store2);
   } else {
     assert (0 && "value type not supported");
@@ -626,12 +626,12 @@ SDValue PIC16TargetLowering::ExpandExternalSymbol(SDNode *N, SelectionDAG &DAG)
   // FIXME there isn't really debug info here
   DebugLoc dl = ES->getDebugLoc();
 
-  SDValue TES = DAG.getTargetExternalSymbol(ES->getSymbol(), MVT::i8);
-  SDValue Offset = DAG.getConstant(0, MVT::i8);
-  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, MVT::i8, TES, Offset);
-  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, MVT::i8, TES, Offset);
+  SDValue TES = DAG.getTargetExternalSymbol(ES->getSymbol(), EVT::i8);
+  SDValue Offset = DAG.getConstant(0, EVT::i8);
+  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, EVT::i8, TES, Offset);
+  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, EVT::i8, TES, Offset);
 
-  return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i16, Lo, Hi);
+  return DAG.getNode(ISD::BUILD_PAIR, dl, EVT::i16, Lo, Hi);
 }
 
 // ExpandGlobalAddress - 
@@ -640,14 +640,14 @@ SDValue PIC16TargetLowering::ExpandGlobalAddress(SDNode *N, SelectionDAG &DAG) {
   // FIXME there isn't really debug info here
   DebugLoc dl = G->getDebugLoc();
   
-  SDValue TGA = DAG.getTargetGlobalAddress(G->getGlobal(), MVT::i8,
+  SDValue TGA = DAG.getTargetGlobalAddress(G->getGlobal(), EVT::i8,
                                            G->getOffset());
 
-  SDValue Offset = DAG.getConstant(0, MVT::i8);
-  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, MVT::i8, TGA, Offset);
-  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, MVT::i8, TGA, Offset);
+  SDValue Offset = DAG.getConstant(0, EVT::i8);
+  SDValue Lo = DAG.getNode(PIC16ISD::Lo, dl, EVT::i8, TGA, Offset);
+  SDValue Hi = DAG.getNode(PIC16ISD::Hi, dl, EVT::i8, TGA, Offset);
 
-  return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i16, Lo, Hi);
+  return DAG.getNode(ISD::BUILD_PAIR, dl, EVT::i16, Lo, Hi);
 }
 
 bool PIC16TargetLowering::isDirectAddress(const SDValue &Op) {
@@ -690,15 +690,15 @@ void PIC16TargetLowering::GetExpandedParts(SDValue Op, SelectionDAG &DAG,
                                            SDValue &Lo, SDValue &Hi) {  
   SDNode *N = Op.getNode();
   DebugLoc dl = N->getDebugLoc();
-  MVT NewVT = getTypeToTransformTo(N->getValueType(0));
+  EVT NewVT = getTypeToTransformTo(N->getValueType(0));
 
   // Extract the lo component.
   Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NewVT, Op,
-                   DAG.getConstant(0, MVT::i8));
+                   DAG.getConstant(0, EVT::i8));
 
   // extract the hi component
   Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NewVT, Op,
-                   DAG.getConstant(1, MVT::i8));
+                   DAG.getConstant(1, EVT::i8));
 }
 
 // Legalize FrameIndex into ExternalSymbol and offset.
@@ -722,7 +722,7 @@ PIC16TargetLowering::LegalizeFrameIndex(SDValue Op, SelectionDAG &DAG,
   const char *tmpName;
   if (FIndex < ReservedFrameCount) {
     tmpName = createESName(PAN::getFrameLabel(Name));
-    ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
+    ES = DAG.getTargetExternalSymbol(tmpName, EVT::i8);
     Offset = 0;
     for (unsigned i=0; i<FIndex ; ++i) {
       Offset += MFI->getObjectSize(i);
@@ -730,7 +730,7 @@ PIC16TargetLowering::LegalizeFrameIndex(SDValue Op, SelectionDAG &DAG,
   } else {
    // FrameIndex has been made for some temporary storage 
     tmpName = createESName(PAN::getTempdataLabel(Name));
-    ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
+    ES = DAG.getTargetExternalSymbol(tmpName, EVT::i8);
     Offset = GetTmpOffsetForFI(FIndex, MFI->getObjectSize(FIndex));
   }
 
@@ -776,11 +776,11 @@ void PIC16TargetLowering::LegalizeAddress(SDValue Ptr, SelectionDAG &DAG,
   // then treat it as direct address.
   // One example for such case is storing and loading
   // from function frame during a call
-  if (Ptr.getValueType() == MVT::i8) {
+  if (Ptr.getValueType() == EVT::i8) {
     switch (Ptr.getOpcode()) {
     case ISD::TargetExternalSymbol:
       Lo = Ptr;
-      Hi = DAG.getConstant(1, MVT::i8);
+      Hi = DAG.getConstant(1, EVT::i8);
       return;
     }
   }
@@ -791,14 +791,14 @@ void PIC16TargetLowering::LegalizeAddress(SDValue Ptr, SelectionDAG &DAG,
       int FrameOffset;
       if (TFI.getOpcode() == ISD::TargetFrameIndex) {
         LegalizeFrameIndex(TFI, DAG, Lo, FrameOffset);
-        Hi = DAG.getConstant(1, MVT::i8);
+        Hi = DAG.getConstant(1, EVT::i8);
         Offset += FrameOffset; 
         return;
       } else if (TFI.getOpcode() == ISD::TargetExternalSymbol) {
         // FrameIndex has already been expanded.
         // Now just make use of its expansion
         Lo = TFI;
-        Hi = DAG.getConstant(1, MVT::i8);
+        Hi = DAG.getConstant(1, EVT::i8);
         SDValue FOffset = Ptr.getOperand(0).getOperand(1);
         assert (FOffset.getOpcode() == ISD::Constant && 
                           "Invalid operand of PIC16ISD::Lo");
@@ -816,7 +816,7 @@ void PIC16TargetLowering::LegalizeAddress(SDValue Ptr, SelectionDAG &DAG,
     // signifies that banksel needs to generated for it. Value 0 for
     // the constant signifies that banksel does not need to be generated 
     // for it. Mark it as 1 now and optimize later. 
-    Hi = DAG.getConstant(1, MVT::i8);
+    Hi = DAG.getConstant(1, EVT::i8);
     return; 
   }
 
@@ -824,8 +824,8 @@ void PIC16TargetLowering::LegalizeAddress(SDValue Ptr, SelectionDAG &DAG,
   GetExpandedParts(Ptr, DAG, Lo, Hi);
 
   // Put the hi and lo parts into FSR.
-  Lo = DAG.getNode(PIC16ISD::MTLO, dl, MVT::i8, Lo);
-  Hi = DAG.getNode(PIC16ISD::MTHI, dl, MVT::i8, Hi);
+  Lo = DAG.getNode(PIC16ISD::MTLO, dl, EVT::i8, Lo);
+  Hi = DAG.getNode(PIC16ISD::MTHI, dl, EVT::i8, Hi);
 
   return;
 }
@@ -838,7 +838,7 @@ SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
 
   SDValue Load, Offset;
   SDVTList Tys; 
-  MVT VT, NewVT;
+  EVT VT, NewVT;
   SDValue PtrLo, PtrHi;
   unsigned LoadOffset;
 
@@ -851,12 +851,12 @@ SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
   unsigned NumLoads = VT.getSizeInBits() / 8; 
   std::vector<SDValue> PICLoads;
   unsigned iter;
-  MVT MemVT = LD->getMemoryVT();
+  EVT MemVT = LD->getMemoryVT();
   if(ISD::isNON_EXTLoad(N)) {
     for (iter=0; iter<NumLoads ; ++iter) {
       // Add the pointer offset if any
-      Offset = DAG.getConstant(iter + LoadOffset, MVT::i8);
-      Tys = DAG.getVTList(MVT::i8, MVT::Other); 
+      Offset = DAG.getConstant(iter + LoadOffset, EVT::i8);
+      Tys = DAG.getVTList(EVT::i8, EVT::Other); 
       Load = DAG.getNode(PIC16ISD::PIC16Load, dl, Tys, Chain, PtrLo, PtrHi,
                          Offset); 
       PICLoads.push_back(Load);
@@ -869,20 +869,20 @@ SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
     
     // For extended loads this is the memory value type
     // i.e. without any extension
-    MVT MemVT = LD->getMemoryVT();
+    EVT MemVT = LD->getMemoryVT();
     unsigned MemBytes = MemVT.getSizeInBits() / 8;
-    // if MVT::i1 is extended to MVT::i8 then MemBytes will be zero
+    // if EVT::i1 is extended to EVT::i8 then MemBytes will be zero
     // So set it to one
     if (MemBytes == 0) MemBytes = 1;
     
     unsigned ExtdBytes = VT.getSizeInBits() / 8;
-    Offset = DAG.getConstant(LoadOffset, MVT::i8);
+    Offset = DAG.getConstant(LoadOffset, EVT::i8);
 
-    Tys = DAG.getVTList(MVT::i8, MVT::Other); 
+    Tys = DAG.getVTList(EVT::i8, EVT::Other); 
     // For MemBytes generate PIC16Load with proper offset
     for (iter=0; iter < MemBytes; ++iter) {
       // Add the pointer offset if any
-      Offset = DAG.getConstant(iter + LoadOffset, MVT::i8);
+      Offset = DAG.getConstant(iter + LoadOffset, EVT::i8);
       Load = DAG.getNode(PIC16ISD::PIC16Load, dl, Tys, Chain, PtrLo, PtrHi,
                          Offset); 
       PICLoads.push_back(Load);
@@ -892,15 +892,15 @@ SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
     if (ISD::isSEXTLoad(N)) {
       // For all ExtdBytes use the Right Shifted(Arithmetic) Value of the 
       // highest MemByte
-      SDValue SRA = DAG.getNode(ISD::SRA, dl, MVT::i8, Load, 
-                                DAG.getConstant(7, MVT::i8));
+      SDValue SRA = DAG.getNode(ISD::SRA, dl, EVT::i8, Load, 
+                                DAG.getConstant(7, EVT::i8));
       for (iter=MemBytes; iter<ExtdBytes; ++iter) { 
         PICLoads.push_back(SRA);
       }
     } else if (ISD::isZEXTLoad(N) || ISD::isEXTLoad(N)) {
     //} else if (ISD::isZEXTLoad(N)) {
       // ZeroExtendedLoad -- For all ExtdBytes use constant 0
-      SDValue ConstZero = DAG.getConstant(0, MVT::i8);
+      SDValue ConstZero = DAG.getConstant(0, EVT::i8);
       for (iter=MemBytes; iter<ExtdBytes; ++iter) { 
         PICLoads.push_back(ConstZero);
       }
@@ -908,46 +908,46 @@ SDValue PIC16TargetLowering::ExpandLoad(SDNode *N, SelectionDAG &DAG) {
   }
   SDValue BP;
 
-  if (VT == MVT::i8) {
+  if (VT == EVT::i8) {
     // Operand of Load is illegal -- Load itself is legal
     return PICLoads[0];
   }
-  else if (VT == MVT::i16) {
+  else if (VT == EVT::i16) {
     BP = DAG.getNode(ISD::BUILD_PAIR, dl, VT, PICLoads[0], PICLoads[1]);
-    if (MemVT == MVT::i8)
+    if (MemVT == EVT::i8)
       Chain = getChain(PICLoads[0]);
     else
-      Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
+      Chain = DAG.getNode(ISD::TokenFactor, dl, EVT::Other, 
                           getChain(PICLoads[0]), getChain(PICLoads[1]));
-  } else if (VT == MVT::i32) {
+  } else if (VT == EVT::i32) {
     SDValue BPs[2];
-    BPs[0] = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i16, 
+    BPs[0] = DAG.getNode(ISD::BUILD_PAIR, dl, EVT::i16, 
                          PICLoads[0], PICLoads[1]);
-    BPs[1] = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i16,
+    BPs[1] = DAG.getNode(ISD::BUILD_PAIR, dl, EVT::i16,
                          PICLoads[2], PICLoads[3]);
     BP = DAG.getNode(ISD::BUILD_PAIR, dl, VT, BPs[0], BPs[1]);
-    if (MemVT == MVT::i8)
+    if (MemVT == EVT::i8)
       Chain = getChain(PICLoads[0]);
-    else if (MemVT == MVT::i16)
-      Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, 
+    else if (MemVT == EVT::i16)
+      Chain = DAG.getNode(ISD::TokenFactor, dl, EVT::Other, 
                           getChain(PICLoads[0]), getChain(PICLoads[1]));
     else {
       SDValue Chains[2];
-      Chains[0] = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
+      Chains[0] = DAG.getNode(ISD::TokenFactor, dl, EVT::Other,
                               getChain(PICLoads[0]), getChain(PICLoads[1]));
-      Chains[1] = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
+      Chains[1] = DAG.getNode(ISD::TokenFactor, dl, EVT::Other,
                               getChain(PICLoads[2]), getChain(PICLoads[3]));
-      Chain =  DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
+      Chain =  DAG.getNode(ISD::TokenFactor, dl, EVT::Other,
                            Chains[0], Chains[1]);
     }
   }
-  Tys = DAG.getVTList(VT, MVT::Other); 
+  Tys = DAG.getVTList(VT, EVT::Other); 
   return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, BP, Chain);
 }
 
 SDValue PIC16TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) {
   // We should have handled larger operands in type legalizer itself.
-  assert (Op.getValueType() == MVT::i8 && "illegal shift to lower");
+  assert (Op.getValueType() == EVT::i8 && "illegal shift to lower");
  
   SDNode *N = Op.getNode();
   SDValue Value = N->getOperand(0);
@@ -977,7 +977,7 @@ SDValue PIC16TargetLowering::LowerShift(SDValue Op, SelectionDAG &DAG) {
 
 SDValue PIC16TargetLowering::LowerMUL(SDValue Op, SelectionDAG &DAG) {
   // We should have handled larger operands in type legalizer itself.
-  assert (Op.getValueType() == MVT::i8 && "illegal multiply to lower");
+  assert (Op.getValueType() == EVT::i8 && "illegal multiply to lower");
 
   SDNode *N = Op.getNode();
   SmallVector<SDValue, 2> Ops(2);
@@ -1050,7 +1050,7 @@ SDValue PIC16TargetLowering::LowerOperation(SDValue Op, SelectionDAG &DAG) {
 SDValue PIC16TargetLowering::ConvertToMemOperand(SDValue Op,
                                                  SelectionDAG &DAG,
                                                  DebugLoc dl) {
-  assert (Op.getValueType() == MVT::i8 
+  assert (Op.getValueType() == EVT::i8 
           && "illegal value type to store on stack.");
 
   MachineFunction &MF = DAG.getMachineFunction();
@@ -1062,22 +1062,22 @@ SDValue PIC16TargetLowering::ConvertToMemOperand(SDValue Op,
   // Get a stack slot index and convert to es.
   int FI = MF.getFrameInfo()->CreateStackObject(1, 1);
   const char *tmpName = createESName(PAN::getTempdataLabel(FuncName));
-  SDValue ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
+  SDValue ES = DAG.getTargetExternalSymbol(tmpName, EVT::i8);
 
   // Store the value to ES.
-  SDValue Store = DAG.getNode (PIC16ISD::PIC16Store, dl, MVT::Other,
+  SDValue Store = DAG.getNode (PIC16ISD::PIC16Store, dl, EVT::Other,
                                DAG.getEntryNode(),
                                Op, ES, 
-                               DAG.getConstant (1, MVT::i8), // Banksel.
+                               DAG.getConstant (1, EVT::i8), // Banksel.
                                DAG.getConstant (GetTmpOffsetForFI(FI, 1), 
-                                                MVT::i8));
+                                                EVT::i8));
 
   // Load the value from ES.
-  SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other);
+  SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Other);
   SDValue Load = DAG.getNode(PIC16ISD::PIC16Load, dl, Tys, Store,
-                             ES, DAG.getConstant (1, MVT::i8),
+                             ES, DAG.getConstant (1, EVT::i8),
                              DAG.getConstant (GetTmpOffsetForFI(FI, 1), 
-                             MVT::i8));
+                             EVT::i8));
     
   return Load.getValue(0);
 }
@@ -1094,7 +1094,7 @@ LowerIndirectCallArguments(SDValue Chain, SDValue InFlag,
     return Chain;
 
   std::vector<SDValue> Ops;
-  SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
+  SDVTList Tys = DAG.getVTList(EVT::Other, EVT::Flag);
   SDValue Arg, StoreRet;
 
   // For PIC16 ABI the arguments come after the return value. 
@@ -1108,7 +1108,7 @@ LowerIndirectCallArguments(SDValue Chain, SDValue InFlag,
     Ops.push_back(Arg);
     Ops.push_back(DataAddr_Lo);
     Ops.push_back(DataAddr_Hi);
-    Ops.push_back(DAG.getConstant(ArgOffset, MVT::i8));
+    Ops.push_back(DAG.getConstant(ArgOffset, EVT::i8));
     Ops.push_back(InFlag);
 
     StoreRet = DAG.getNode (PIC16ISD::PIC16StWF, dl, Tys, &Ops[0], Ops.size());
@@ -1127,7 +1127,7 @@ LowerDirectCallArguments(SDValue ArgLabel, SDValue Chain, SDValue InFlag,
   unsigned NumOps = Outs.size();
   std::string Name;
   SDValue Arg, StoreAt;
-  MVT ArgVT;
+  EVT ArgVT;
   unsigned Size=0;
 
   // If call has no arguments then do nothing and return.
@@ -1145,7 +1145,7 @@ LowerDirectCallArguments(SDValue ArgLabel, SDValue Chain, SDValue InFlag,
   SDValue StoreRet;
 
   std::vector<SDValue> Ops;
-  SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
+  SDVTList Tys = DAG.getVTList(EVT::Other, EVT::Flag);
   for (unsigned i=0, Offset = 0; i<NumOps; i++) {
     // Get the argument
     Arg = Outs[i].Val;
@@ -1158,7 +1158,7 @@ LowerDirectCallArguments(SDValue ArgLabel, SDValue Chain, SDValue InFlag,
     Ops.push_back(Arg);
     Ops.push_back(PtrLo);
     Ops.push_back(PtrHi);
-    Ops.push_back(DAG.getConstant(StoreOffset, MVT::i8));
+    Ops.push_back(DAG.getConstant(StoreOffset, EVT::i8));
     Ops.push_back(InFlag);
 
     StoreRet = DAG.getNode (PIC16ISD::PIC16StWF, dl, Tys, &Ops[0], Ops.size());
@@ -1191,10 +1191,10 @@ LowerIndirectCallReturn(SDValue Chain, SDValue InFlag,
   // Call has something to return
   SDValue LoadRet;
 
-  SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other, MVT::Flag);
+  SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Other, EVT::Flag);
   for(unsigned i=0;i<RetVals;i++) {
     LoadRet = DAG.getNode(PIC16ISD::PIC16LdWF, dl, Tys, Chain, DataAddr_Lo,
-                          DataAddr_Hi, DAG.getConstant(i, MVT::i8),
+                          DataAddr_Hi, DAG.getConstant(i, EVT::i8),
                           InFlag);
     InFlag = getOutFlag(LoadRet);
     Chain = getChain(LoadRet);
@@ -1224,13 +1224,13 @@ LowerDirectCallReturn(SDValue RetLabel, SDValue Chain, SDValue InFlag,
   unsigned LdOffset;
   LegalizeAddress(RetLabel, DAG, LdLo, LdHi, LdOffset, dl);
 
-  SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other, MVT::Flag);
+  SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Other, EVT::Flag);
   SDValue LoadRet;
  
   for(unsigned i=0, Offset=0;i<RetVals;i++) {
 
     LoadRet = DAG.getNode(PIC16ISD::PIC16LdWF, dl, Tys, Chain, LdLo, LdHi,
-                          DAG.getConstant(LdOffset + Offset, MVT::i8),
+                          DAG.getConstant(LdOffset + Offset, EVT::i8),
                           InFlag);
 
     InFlag = getOutFlag(LoadRet);
@@ -1259,18 +1259,18 @@ PIC16TargetLowering::LowerReturn(SDValue Chain,
   std::string FuncName = F->getName();
 
   const char *tmpName = createESName(PAN::getFrameLabel(FuncName));
-  SDVTList VTs  = DAG.getVTList (MVT::i8, MVT::Other);
-  SDValue ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
-  SDValue BS = DAG.getConstant(1, MVT::i8);
+  SDVTList VTs  = DAG.getVTList (EVT::i8, EVT::Other);
+  SDValue ES = DAG.getTargetExternalSymbol(tmpName, EVT::i8);
+  SDValue BS = DAG.getConstant(1, EVT::i8);
   SDValue RetVal;
   for(unsigned i=0;i<NumRet; ++i) {
     RetVal = Outs[i].Val;
-    Chain =  DAG.getNode (PIC16ISD::PIC16Store, dl, MVT::Other, Chain, RetVal,
+    Chain =  DAG.getNode (PIC16ISD::PIC16Store, dl, EVT::Other, Chain, RetVal,
                         ES, BS,
-                        DAG.getConstant (i, MVT::i8));
+                        DAG.getConstant (i, EVT::i8));
       
   }
-  return DAG.getNode(PIC16ISD::RET, dl, MVT::Other, Chain);
+  return DAG.getNode(PIC16ISD::RET, dl, EVT::Other, Chain);
 }
 
 void PIC16TargetLowering::
@@ -1279,7 +1279,7 @@ GetDataAddress(DebugLoc dl, SDValue Callee, SDValue &Chain,
                SelectionDAG &DAG) {
    assert (Callee.getOpcode() == PIC16ISD::PIC16Connect
            && "Don't know what to do of such callee!!");
-   SDValue ZeroOperand = DAG.getConstant(0, MVT::i8);
+   SDValue ZeroOperand = DAG.getConstant(0, EVT::i8);
    SDValue SeqStart  = DAG.getCALLSEQ_START(Chain, ZeroOperand);
    Chain = getChain(SeqStart);
    SDValue OperFlag = getOutFlag(SeqStart); // To manage the data dependency
@@ -1289,15 +1289,15 @@ GetDataAddress(DebugLoc dl, SDValue Callee, SDValue &Chain,
    SDValue Hi = Callee.getOperand(1);
 
    SDValue Data_Lo, Data_Hi;
-   SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Other, MVT::Flag);
+   SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Other, EVT::Flag);
    // Subtract 2 from Address to get the Lower part of DataAddress.
-   SDVTList VTList = DAG.getVTList(MVT::i8, MVT::Flag);
+   SDVTList VTList = DAG.getVTList(EVT::i8, EVT::Flag);
    Data_Lo = DAG.getNode(ISD::SUBC, dl, VTList, Lo, 
-                         DAG.getConstant(2, MVT::i8));
-   SDValue Ops[3] = { Hi, DAG.getConstant(0, MVT::i8), Data_Lo.getValue(1)};
+                         DAG.getConstant(2, EVT::i8));
+   SDValue Ops[3] = { Hi, DAG.getConstant(0, EVT::i8), Data_Lo.getValue(1)};
    Data_Hi = DAG.getNode(ISD::SUBE, dl, VTList, Ops, 3);
-   SDValue PCLATH = DAG.getNode(PIC16ISD::MTPCLATH, dl, MVT::i8, Data_Hi);
-   Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, MVT::i8, Data_Lo, PCLATH);
+   SDValue PCLATH = DAG.getNode(PIC16ISD::MTPCLATH, dl, EVT::i8, Data_Hi);
+   Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, EVT::i8, Data_Lo, PCLATH);
    SDValue Call = DAG.getNode(PIC16ISD::CALLW, dl, Tys, Chain, Callee,
                               OperFlag);
    Chain = getChain(Call);
@@ -1308,7 +1308,7 @@ GetDataAddress(DebugLoc dl, SDValue Callee, SDValue &Chain,
    OperFlag = getOutFlag(SeqEnd);
 
    // Low part of Data Address 
-   DataAddr_Lo = DAG.getNode(PIC16ISD::MTLO, dl, MVT::i8, Call, OperFlag);
+   DataAddr_Lo = DAG.getNode(PIC16ISD::MTLO, dl, EVT::i8, Call, OperFlag);
 
    // Make the second call.
    SeqStart  = DAG.getCALLSEQ_START(Chain, ZeroOperand);
@@ -1317,13 +1317,13 @@ GetDataAddress(DebugLoc dl, SDValue Callee, SDValue &Chain,
 
    // Subtract 1 from Address to get high part of data address.
    Data_Lo = DAG.getNode(ISD::SUBC, dl, VTList, Lo, 
-                         DAG.getConstant(1, MVT::i8));
-   SDValue HiOps[3] = { Hi, DAG.getConstant(0, MVT::i8), Data_Lo.getValue(1)};
+                         DAG.getConstant(1, EVT::i8));
+   SDValue HiOps[3] = { Hi, DAG.getConstant(0, EVT::i8), Data_Lo.getValue(1)};
    Data_Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps, 3);
-   PCLATH = DAG.getNode(PIC16ISD::MTPCLATH, dl, MVT::i8, Data_Hi);
+   PCLATH = DAG.getNode(PIC16ISD::MTPCLATH, dl, EVT::i8, Data_Hi);
 
    // Use new Lo to make another CALLW
-   Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, MVT::i8, Data_Lo, PCLATH);
+   Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, EVT::i8, Data_Lo, PCLATH);
    Call = DAG.getNode(PIC16ISD::CALLW, dl, Tys, Chain, Callee, OperFlag);
    Chain = getChain(Call);
    OperFlag = getOutFlag(Call);
@@ -1332,7 +1332,7 @@ GetDataAddress(DebugLoc dl, SDValue Callee, SDValue &Chain,
    Chain = getChain(SeqEnd);
    OperFlag = getOutFlag(SeqEnd);
    // Hi part of Data Address
-   DataAddr_Hi = DAG.getNode(PIC16ISD::MTHI, dl, MVT::i8, Call, OperFlag);
+   DataAddr_Hi = DAG.getNode(PIC16ISD::MTHI, dl, EVT::i8, Call, OperFlag);
 }
 
 SDValue
@@ -1344,7 +1344,7 @@ PIC16TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
                                DebugLoc dl, SelectionDAG &DAG,
                                SmallVectorImpl<SDValue> &InVals) {
 
-    assert(Callee.getValueType() == MVT::i16 &&
+    assert(Callee.getValueType() == EVT::i16 &&
            "Don't know how to legalize this call node!!!");
 
     // The flag to track if this is a direct or indirect call.
@@ -1367,7 +1367,7 @@ PIC16TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
        // Indirect addresses. Get the hi and lo parts of ptr.
        GetExpandedParts(Callee, DAG, Lo, Hi);
        // Connect Lo and Hi parts of the callee with the PIC16Connect
-       Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, MVT::i8, Lo, Hi);
+       Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, EVT::i8, Lo, Hi);
 
        // Read DataAddress only if we have to pass arguments or 
        // read return value. 
@@ -1375,7 +1375,7 @@ PIC16TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
          GetDataAddress(dl, Callee, Chain, DataAddr_Lo, DataAddr_Hi, DAG);
     }
 
-    SDValue ZeroOperand = DAG.getConstant(0, MVT::i8);
+    SDValue ZeroOperand = DAG.getConstant(0, EVT::i8);
 
     // Start the call sequence.
     // Carring the Constant 0 along the CALLSEQSTART
@@ -1392,32 +1392,32 @@ PIC16TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
        // Considering the GlobalAddressNode case here.
        if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
           GlobalValue *GV = G->getGlobal();
-          Callee = DAG.getTargetGlobalAddress(GV, MVT::i8);
+          Callee = DAG.getTargetGlobalAddress(GV, EVT::i8);
           Name = G->getGlobal()->getName();
        } else {// Considering the ExternalSymbol case here
           ExternalSymbolSDNode *ES = dyn_cast<ExternalSymbolSDNode>(Callee);
-          Callee = DAG.getTargetExternalSymbol(ES->getSymbol(), MVT::i8); 
+          Callee = DAG.getTargetExternalSymbol(ES->getSymbol(), EVT::i8); 
           Name = ES->getSymbol();
        }
 
        // Label for argument passing
        const char *argFrame = createESName(PAN::getArgsLabel(Name));
-       ArgLabel = DAG.getTargetExternalSymbol(argFrame, MVT::i8);
+       ArgLabel = DAG.getTargetExternalSymbol(argFrame, EVT::i8);
 
        // Label for reading return value
        const char *retName = createESName(PAN::getRetvalLabel(Name));
-       RetLabel = DAG.getTargetExternalSymbol(retName, MVT::i8);
+       RetLabel = DAG.getTargetExternalSymbol(retName, EVT::i8);
     } else {
        // if indirect call
        SDValue CodeAddr_Lo = Callee.getOperand(0);
        SDValue CodeAddr_Hi = Callee.getOperand(1);
 
-       /*CodeAddr_Lo = DAG.getNode(ISD::ADD, dl, MVT::i8, CodeAddr_Lo,
-                                 DAG.getConstant(2, MVT::i8));*/
+       /*CodeAddr_Lo = DAG.getNode(ISD::ADD, dl, EVT::i8, CodeAddr_Lo,
+                                 DAG.getConstant(2, EVT::i8));*/
 
        // move Hi part in PCLATH
-       CodeAddr_Hi = DAG.getNode(PIC16ISD::MTPCLATH, dl, MVT::i8, CodeAddr_Hi);
-       Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, MVT::i8, CodeAddr_Lo,
+       CodeAddr_Hi = DAG.getNode(PIC16ISD::MTPCLATH, dl, EVT::i8, CodeAddr_Hi);
+       Callee = DAG.getNode(PIC16ISD::PIC16Connect, dl, EVT::i8, CodeAddr_Lo,
                             CodeAddr_Hi);
     } 
 
@@ -1435,7 +1435,7 @@ PIC16TargetLowering::LowerCall(SDValue Chain, SDValue Callee,
       OperFlag = getOutFlag(CallArgs);
     }
 
-    SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Flag);
+    SDVTList Tys = DAG.getVTList(EVT::Other, EVT::Flag);
     SDValue PICCall = DAG.getNode(PIC16ISD::CALL, dl, Tys, Chain, Callee,
                                   OperFlag);
     Chain = getChain(PICCall);
@@ -1500,14 +1500,14 @@ SDValue PIC16TargetLowering::LowerBinOp(SDValue Op, SelectionDAG &DAG) {
   DebugLoc dl = Op.getDebugLoc();
 
   // We should have handled larger operands in type legalizer itself.
-  assert (Op.getValueType() == MVT::i8 && "illegal Op to lower");
+  assert (Op.getValueType() == EVT::i8 && "illegal Op to lower");
 
   unsigned MemOp = 1;
   if (NeedToConvertToMemOp(Op, MemOp)) {
     // Put one value on stack.
     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG, dl);
 
-    return DAG.getNode(Op.getOpcode(), dl, MVT::i8, Op.getOperand(MemOp ^ 1),
+    return DAG.getNode(Op.getOpcode(), dl, EVT::i8, Op.getOperand(MemOp ^ 1),
     NewVal);
   }
   else {
@@ -1519,7 +1519,7 @@ SDValue PIC16TargetLowering::LowerBinOp(SDValue Op, SelectionDAG &DAG) {
 // that affects carry.
 SDValue PIC16TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) {
   // We should have handled larger operands in type legalizer itself.
-  assert (Op.getValueType() == MVT::i8 && "illegal add to lower");
+  assert (Op.getValueType() == EVT::i8 && "illegal add to lower");
   DebugLoc dl = Op.getDebugLoc();
   unsigned MemOp = 1;
   if (NeedToConvertToMemOp(Op, MemOp)) {
@@ -1527,7 +1527,7 @@ SDValue PIC16TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) {
     SDValue NewVal = ConvertToMemOperand (Op.getOperand(MemOp), DAG, dl);
     
     // ADDC and ADDE produce two results.
-    SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
+    SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Flag);
 
     // ADDE has three operands, the last one is the carry bit.
     if (Op.getOpcode() == ISD::ADDE)
@@ -1539,7 +1539,7 @@ SDValue PIC16TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) {
                          NewVal);
     // ADD it is. It produces only one result.
     else
-      return DAG.getNode(Op.getOpcode(), dl, MVT::i8, Op.getOperand(MemOp ^ 1),
+      return DAG.getNode(Op.getOpcode(), dl, EVT::i8, Op.getOperand(MemOp ^ 1),
                          NewVal);
   }
   else
@@ -1549,7 +1549,7 @@ SDValue PIC16TargetLowering::LowerADD(SDValue Op, SelectionDAG &DAG) {
 SDValue PIC16TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) {
   DebugLoc dl = Op.getDebugLoc();
   // We should have handled larger operands in type legalizer itself.
-  assert (Op.getValueType() == MVT::i8 && "illegal sub to lower");
+  assert (Op.getValueType() == EVT::i8 && "illegal sub to lower");
 
   // Nothing to do if the first operand is already a direct load and it has
   // only one use.
@@ -1559,7 +1559,7 @@ SDValue PIC16TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) {
   // Put first operand on stack.
   SDValue NewVal = ConvertToMemOperand (Op.getOperand(0), DAG, dl);
 
-  SDVTList Tys = DAG.getVTList(MVT::i8, MVT::Flag);
+  SDVTList Tys = DAG.getVTList(EVT::i8, EVT::Flag);
   switch (Op.getOpcode()) {
     default:
       assert (0 && "Opcode unknown."); 
@@ -1571,7 +1571,7 @@ SDValue PIC16TargetLowering::LowerSUB(SDValue Op, SelectionDAG &DAG) {
       return DAG.getNode(Op.getOpcode(), dl, Tys, NewVal, Op.getOperand(1));
       break;
     case ISD::SUB:
-      return DAG.getNode(Op.getOpcode(), dl, MVT::i8, NewVal, Op.getOperand(1));
+      return DAG.getNode(Op.getOpcode(), dl, EVT::i8, NewVal, Op.getOperand(1));
       break;
   }
 }
@@ -1613,13 +1613,13 @@ PIC16TargetLowering::LowerFormalArguments(SDValue Chain,
 
   // Create the <fname>.args external symbol.
   const char *tmpName = createESName(PAN::getArgsLabel(FuncName));
-  SDValue ES = DAG.getTargetExternalSymbol(tmpName, MVT::i8);
+  SDValue ES = DAG.getTargetExternalSymbol(tmpName, EVT::i8);
 
   // Load arg values from the label + offset.
-  SDVTList VTs  = DAG.getVTList (MVT::i8, MVT::Other);
-  SDValue BS = DAG.getConstant(1, MVT::i8);
+  SDVTList VTs  = DAG.getVTList (EVT::i8, EVT::Other);
+  SDValue BS = DAG.getConstant(1, EVT::i8);
   for (unsigned i = 0; i < NumArgVals ; ++i) {
-    SDValue Offset = DAG.getConstant(i, MVT::i8);
+    SDValue Offset = DAG.getConstant(i, EVT::i8);
     SDValue PICLoad = DAG.getNode(PIC16ISD::PIC16LdArg, dl, VTs, Chain, ES, BS,
                                   Offset);
     Chain = getChain(PICLoad);
@@ -1751,16 +1751,16 @@ SDValue PIC16TargetLowering::getPIC16Cmp(SDValue LHS, SDValue RHS,
     }
   }
 
-  PIC16CC = DAG.getConstant(CondCode, MVT::i8);
+  PIC16CC = DAG.getConstant(CondCode, EVT::i8);
 
   // These are signed comparisons. 
-  SDValue Mask = DAG.getConstant(128, MVT::i8);
+  SDValue Mask = DAG.getConstant(128, EVT::i8);
   if (isSignedComparison(CondCode)) {
-    LHS = DAG.getNode (ISD::XOR, dl, MVT::i8, LHS, Mask);
-    RHS = DAG.getNode (ISD::XOR, dl, MVT::i8, RHS, Mask); 
+    LHS = DAG.getNode (ISD::XOR, dl, EVT::i8, LHS, Mask);
+    RHS = DAG.getNode (ISD::XOR, dl, EVT::i8, RHS, Mask); 
   }
 
-  SDVTList VTs = DAG.getVTList (MVT::i8, MVT::Flag);
+  SDVTList VTs = DAG.getVTList (EVT::i8, EVT::Flag);
   // We can use a subtract operation to set the condition codes. But
   // we need to put one operand in memory if required.
   // Nothing to do if the first operand is already a valid type (direct load 
@@ -1875,7 +1875,7 @@ SDValue PIC16TargetLowering::LowerBR_CC(SDValue Op, SelectionDAG &DAG) {
   SDValue PIC16CC;
   SDValue Cmp = getPIC16Cmp(LHS, RHS, ORIGCC, PIC16CC, DAG, dl);
 
-  return DAG.getNode(PIC16ISD::BRCOND, dl, MVT::Other, Chain, Dest, PIC16CC, 
+  return DAG.getNode(PIC16ISD::BRCOND, dl, EVT::Other, Chain, Dest, PIC16CC, 
                      Cmp.getValue(1));
 }
 
diff --git a/lib/Target/PIC16/PIC16ISelLowering.h b/lib/Target/PIC16/PIC16ISelLowering.h
index 968374c..5069153 100644
--- a/lib/Target/PIC16/PIC16ISelLowering.h
+++ b/lib/Target/PIC16/PIC16ISelLowering.h
@@ -82,7 +82,7 @@ namespace llvm {
     /// DAG node.
     virtual const char *getTargetNodeName(unsigned Opcode) const;
     /// getSetCCResultType - Return the ISD::SETCC ValueType
-    virtual MVT::SimpleValueType getSetCCResultType(MVT ValType) const;
+    virtual EVT::SimpleValueType getSetCCResultType(EVT ValType) const;
     SDValue LowerShift(SDValue Op, SelectionDAG &DAG);
     SDValue LowerMUL(SDValue Op, SelectionDAG &DAG);
     SDValue LowerADD(SDValue Op, SelectionDAG &DAG);
@@ -230,7 +230,7 @@ namespace llvm {
     const char *getPIC16LibcallName(PIC16ISD::PIC16Libcall Call);
 
     // Make PIC16 Libcall.
-    SDValue MakePIC16Libcall(PIC16ISD::PIC16Libcall Call, MVT RetVT, 
+    SDValue MakePIC16Libcall(PIC16ISD::PIC16Libcall Call, EVT RetVT, 
                              const SDValue *Ops, unsigned NumOps, bool isSigned,
                              SelectionDAG &DAG, DebugLoc dl);