Wrap MVT::ValueType in a struct to get type safety

and better control the abstraction.  Rename the type
to MVT.  To update out-of-tree patches, the main
thing to do is to rename MVT::ValueType to MVT, and
rewrite expressions like MVT::getSizeInBits(VT) in
the form VT.getSizeInBits().  Use VT.getSimpleVT()
to extract a MVT::SimpleValueType for use in switch
statements (you will get an assert failure if VT is
an extended value type - these shouldn't exist after
type legalization).
This results in a small speedup of codegen and no
new testsuite failures (x86-64 linux).


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

68 files changed, 2862 insertions, 2845 deletions

diff --git a/docs/CodeGenerator.html b/docs/CodeGenerator.html
index bcbb64cafb..a283981c7c 100644
--- a/docs/CodeGenerator.html
+++ b/docs/CodeGenerator.html
@@ -790,7 +790,8 @@ to the node defining the used value.  Because nodes may define multiple values,
 edges are represented by instances of the <tt>SDOperand</tt> class, which is 
 a <tt>&lt;SDNode, unsigned&gt;</tt> pair, indicating the node and result
 value being used, respectively.  Each value produced by an <tt>SDNode</tt> has
-an associated <tt>MVT::ValueType</tt> indicating what type the value is.</p>
+an associated <tt>MVT</tt> (Machine Value Type) indicating what the type of the
+value is.</p>
 
 <p>SelectionDAGs contain two different kinds of values: those that represent
 data flow and those that represent control flow dependencies.  Data values are
diff --git a/include/llvm/CodeGen/CallingConvLower.h b/include/llvm/CodeGen/CallingConvLower.h
index 584cb19939..2fda9e5bfb 100644
--- a/include/llvm/CodeGen/CallingConvLower.h
+++ b/include/llvm/CodeGen/CallingConvLower.h
@@ -49,14 +49,14 @@ private:
   LocInfo HTP : 7;
   
   /// ValVT - The type of the value being assigned.
-  MVT::ValueType ValVT;
+  MVT ValVT;
 
   /// LocVT - The type of the location being assigned to.
-  MVT::ValueType LocVT;
+  MVT LocVT;
 public:
     
-  static CCValAssign getReg(unsigned ValNo, MVT::ValueType ValVT,
-                            unsigned RegNo, MVT::ValueType LocVT,
+  static CCValAssign getReg(unsigned ValNo, MVT ValVT,
+                            unsigned RegNo, MVT LocVT,
                             LocInfo HTP) {
     CCValAssign Ret;
     Ret.ValNo = ValNo;
@@ -67,8 +67,8 @@ public:
     Ret.LocVT = LocVT;
     return Ret;
   }
-  static CCValAssign getMem(unsigned ValNo, MVT::ValueType ValVT,
-                            unsigned Offset, MVT::ValueType LocVT,
+  static CCValAssign getMem(unsigned ValNo, MVT ValVT,
+                            unsigned Offset, MVT LocVT,
                             LocInfo HTP) {
     CCValAssign Ret;
     Ret.ValNo = ValNo;
@@ -81,14 +81,14 @@ public:
   }
   
   unsigned getValNo() const { return ValNo; }
-  MVT::ValueType getValVT() const { return ValVT; }
+  MVT getValVT() const { return ValVT; }
 
   bool isRegLoc() const { return !isMem; }
   bool isMemLoc() const { return isMem; }
   
   unsigned getLocReg() const { assert(isRegLoc()); return Loc; }
   unsigned getLocMemOffset() const { assert(isMemLoc()); return Loc; }
-  MVT::ValueType getLocVT() const { return LocVT; }
+  MVT getLocVT() const { return LocVT; }
   
   LocInfo getLocInfo() const { return HTP; }
 };
@@ -96,8 +96,8 @@ public:
 
 /// CCAssignFn - This function assigns a location for Val, updating State to
 /// reflect the change.
-typedef bool CCAssignFn(unsigned ValNo, MVT::ValueType ValVT,
-                        MVT::ValueType LocVT, CCValAssign::LocInfo LocInfo,
+typedef bool CCAssignFn(unsigned ValNo, MVT ValVT,
+                        MVT LocVT, CCValAssign::LocInfo LocInfo,
                         ISD::ArgFlagsTy ArgFlags, CCState &State);
 
   
@@ -217,8 +217,8 @@ public:
   // HandleByVal - Allocate a stack slot large enough to pass an argument by
   // value. The size and alignment information of the argument is encoded in its
   // parameter attribute.
-  void HandleByVal(unsigned ValNo, MVT::ValueType ValVT,
-                   MVT::ValueType LocVT, CCValAssign::LocInfo LocInfo,
+  void HandleByVal(unsigned ValNo, MVT ValVT,
+                   MVT LocVT, CCValAssign::LocInfo LocInfo,
                    int MinSize, int MinAlign, ISD::ArgFlagsTy ArgFlags);
 
 private:
diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index 77405e46a3..e11bd42cca 100644
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -144,24 +144,22 @@ public:
 
   /// getVTList - Return an SDVTList that represents the list of values
   /// specified.
-  SDVTList getVTList(MVT::ValueType VT);
-  SDVTList getVTList(MVT::ValueType VT1, MVT::ValueType VT2);
-  SDVTList getVTList(MVT::ValueType VT1, MVT::ValueType VT2,MVT::ValueType VT3);
-  SDVTList getVTList(const MVT::ValueType *VTs, unsigned NumVTs);
+  SDVTList getVTList(MVT VT);
+  SDVTList getVTList(MVT VT1, MVT VT2);
+  SDVTList getVTList(MVT VT1, MVT VT2, MVT VT3);
+  SDVTList getVTList(const MVT *VTs, unsigned NumVTs);
   
   /// getNodeValueTypes - These are obsolete, use getVTList instead.
-  const MVT::ValueType *getNodeValueTypes(MVT::ValueType VT) {
+  const MVT *getNodeValueTypes(MVT VT) {
     return getVTList(VT).VTs;
   }
-  const MVT::ValueType *getNodeValueTypes(MVT::ValueType VT1, 
-                                          MVT::ValueType VT2) {
+  const MVT *getNodeValueTypes(MVT VT1, MVT VT2) {
     return getVTList(VT1, VT2).VTs;
   }
-  const MVT::ValueType *getNodeValueTypes(MVT::ValueType VT1,MVT::ValueType VT2,
-                                          MVT::ValueType VT3) {
+  const MVT *getNodeValueTypes(MVT VT1, MVT VT2, MVT VT3) {
     return getVTList(VT1, VT2, VT3).VTs;
   }
-  const MVT::ValueType *getNodeValueTypes(std::vector<MVT::ValueType> &vtList) {
+  const MVT *getNodeValueTypes(std::vector<MVT> &vtList) {
     return getVTList(&vtList[0], (unsigned)vtList.size()).VTs;
   }
   
@@ -170,57 +168,56 @@ public:
   // Node creation methods.
   //
   SDOperand getString(const std::string &Val);
-  SDOperand getConstant(uint64_t Val, MVT::ValueType VT, bool isTarget = false);
-  SDOperand getConstant(const APInt &Val, MVT::ValueType VT, bool isTarget = false);
+  SDOperand getConstant(uint64_t Val, MVT VT, bool isTarget = false);
+  SDOperand getConstant(const APInt &Val, MVT VT, bool isTarget = false);
   SDOperand getIntPtrConstant(uint64_t Val, bool isTarget = false);
-  SDOperand getTargetConstant(uint64_t Val, MVT::ValueType VT) {
+  SDOperand getTargetConstant(uint64_t Val, MVT VT) {
     return getConstant(Val, VT, true);
   }
-  SDOperand getTargetConstant(const APInt &Val, MVT::ValueType VT) {
+  SDOperand getTargetConstant(const APInt &Val, MVT VT) {
     return getConstant(Val, VT, true);
   }
-  SDOperand getConstantFP(double Val, MVT::ValueType VT, bool isTarget = false);
-  SDOperand getConstantFP(const APFloat& Val, MVT::ValueType VT, 
-                          bool isTarget = false);
-  SDOperand getTargetConstantFP(double Val, MVT::ValueType VT) {
+  SDOperand getConstantFP(double Val, MVT VT, bool isTarget = false);
+  SDOperand getConstantFP(const APFloat& Val, MVT VT, bool isTarget = false);
+  SDOperand getTargetConstantFP(double Val, MVT VT) {
     return getConstantFP(Val, VT, true);
   }
-  SDOperand getTargetConstantFP(const APFloat& Val, MVT::ValueType VT) {
+  SDOperand getTargetConstantFP(const APFloat& Val, MVT VT) {
     return getConstantFP(Val, VT, true);
   }
-  SDOperand getGlobalAddress(const GlobalValue *GV, MVT::ValueType VT,
+  SDOperand getGlobalAddress(const GlobalValue *GV, MVT VT,
                              int offset = 0, bool isTargetGA = false);
-  SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT::ValueType VT,
+  SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT VT,
                                    int offset = 0) {
     return getGlobalAddress(GV, VT, offset, true);
   }
-  SDOperand getFrameIndex(int FI, MVT::ValueType VT, bool isTarget = false);
-  SDOperand getTargetFrameIndex(int FI, MVT::ValueType VT) {
+  SDOperand getFrameIndex(int FI, MVT VT, bool isTarget = false);
+  SDOperand getTargetFrameIndex(int FI, MVT VT) {
     return getFrameIndex(FI, VT, true);
   }
-  SDOperand getJumpTable(int JTI, MVT::ValueType VT, bool isTarget = false);
-  SDOperand getTargetJumpTable(int JTI, MVT::ValueType VT) {
+  SDOperand getJumpTable(int JTI, MVT VT, bool isTarget = false);
+  SDOperand getTargetJumpTable(int JTI, MVT VT) {
     return getJumpTable(JTI, VT, true);
   }
-  SDOperand getConstantPool(Constant *C, MVT::ValueType VT,
+  SDOperand getConstantPool(Constant *C, MVT VT,
                             unsigned Align = 0, int Offs = 0, bool isT=false);
-  SDOperand getTargetConstantPool(Constant *C, MVT::ValueType VT,
+  SDOperand getTargetConstantPool(Constant *C, MVT VT,
                                   unsigned Align = 0, int Offset = 0) {
     return getConstantPool(C, VT, Align, Offset, true);
   }
-  SDOperand getConstantPool(MachineConstantPoolValue *C, MVT::ValueType VT,
+  SDOperand getConstantPool(MachineConstantPoolValue *C, MVT VT,
                             unsigned Align = 0, int Offs = 0, bool isT=false);
   SDOperand getTargetConstantPool(MachineConstantPoolValue *C,
-                                  MVT::ValueType VT, unsigned Align = 0,
+                                  MVT VT, unsigned Align = 0,
                                   int Offset = 0) {
     return getConstantPool(C, VT, Align, Offset, true);
   }
   SDOperand getBasicBlock(MachineBasicBlock *MBB);
-  SDOperand getExternalSymbol(const char *Sym, MVT::ValueType VT);
-  SDOperand getTargetExternalSymbol(const char *Sym, MVT::ValueType VT);
+  SDOperand getExternalSymbol(const char *Sym, MVT VT);
+  SDOperand getTargetExternalSymbol(const char *Sym, MVT VT);
   SDOperand getArgFlags(ISD::ArgFlagsTy Flags);
-  SDOperand getValueType(MVT::ValueType);
-  SDOperand getRegister(unsigned Reg, MVT::ValueType VT);
+  SDOperand getValueType(MVT);
+  SDOperand getRegister(unsigned Reg, MVT VT);
 
   SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N) {
     return getNode(ISD::CopyToReg, MVT::Other, Chain,
@@ -232,7 +229,7 @@ public:
   // null) and that there should be a flag result.
   SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N,
                          SDOperand Flag) {
-    const MVT::ValueType *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
+    const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
     SDOperand Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Flag };
     return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3);
   }
@@ -240,13 +237,13 @@ public:
   // Similar to last getCopyToReg() except parameter Reg is a SDOperand
   SDOperand getCopyToReg(SDOperand Chain, SDOperand Reg, SDOperand N,
                          SDOperand Flag) {
-    const MVT::ValueType *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
+    const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
     SDOperand Ops[] = { Chain, Reg, N, Flag };
     return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3);
   }
   
-  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT::ValueType VT) {
-    const MVT::ValueType *VTs = getNodeValueTypes(VT, MVT::Other);
+  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT VT) {
+    const MVT *VTs = getNodeValueTypes(VT, MVT::Other);
     SDOperand Ops[] = { Chain, getRegister(Reg, VT) };
     return getNode(ISD::CopyFromReg, VTs, 2, Ops, 2);
   }
@@ -254,9 +251,9 @@ public:
   // This version of the getCopyFromReg method takes an extra operand, which
   // indicates that there is potentially an incoming flag value (if Flag is not
   // null) and that there should be a flag result.
-  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT::ValueType VT,
+  SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT VT,
                            SDOperand Flag) {
-    const MVT::ValueType *VTs = getNodeValueTypes(VT, MVT::Other, MVT::Flag);
+    const MVT *VTs = getNodeValueTypes(VT, MVT::Other, MVT::Flag);
     SDOperand Ops[] = { Chain, getRegister(Reg, VT), Flag };
     return getNode(ISD::CopyFromReg, VTs, 3, Ops, Flag.Val ? 3 : 2);
   }
@@ -265,12 +262,12 @@ public:
 
   /// getZeroExtendInReg - Return the expression required to zero extend the Op
   /// value assuming it was the smaller SrcTy value.
-  SDOperand getZeroExtendInReg(SDOperand Op, MVT::ValueType SrcTy);
+  SDOperand getZeroExtendInReg(SDOperand Op, MVT SrcTy);
   
   /// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have
   /// a flag result (to ensure it's not CSE'd).
   SDOperand getCALLSEQ_START(SDOperand Chain, SDOperand Op) {
-    const MVT::ValueType *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
+    const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
     SDOperand Ops[] = { Chain,  Op };
     return getNode(ISD::CALLSEQ_START, VTs, 2, Ops, 2);
   }
@@ -291,27 +288,24 @@ public:
 
   /// getNode - Gets or creates the specified node.
   ///
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
-                    SDOperand N1, SDOperand N2);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+  SDOperand getNode(unsigned Opcode, MVT VT);
+  SDOperand getNode(unsigned Opcode, MVT VT, SDOperand N);
+  SDOperand getNode(unsigned Opcode, MVT VT, SDOperand N1, SDOperand N2);
+  SDOperand getNode(unsigned Opcode, MVT VT,
                     SDOperand N1, SDOperand N2, SDOperand N3);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+  SDOperand getNode(unsigned Opcode, MVT VT,
                     SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+  SDOperand getNode(unsigned Opcode, MVT VT,
                     SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4,
                     SDOperand N5);
-  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+  SDOperand getNode(unsigned Opcode, MVT VT, SDOperandPtr Ops, unsigned NumOps);
+  SDOperand getNode(unsigned Opcode, std::vector<MVT> &ResultTys,
                     SDOperandPtr Ops, unsigned NumOps);
-  SDOperand getNode(unsigned Opcode, std::vector<MVT::ValueType> &ResultTys,
-                    SDOperandPtr Ops, unsigned NumOps);
-  SDOperand getNode(unsigned Opcode, const MVT::ValueType *VTs, unsigned NumVTs,
+  SDOperand getNode(unsigned Opcode, const MVT *VTs, unsigned NumVTs,
                     SDOperandPtr Ops, unsigned NumOps);
   SDOperand getNode(unsigned Opcode, SDVTList VTs);
   SDOperand getNode(unsigned Opcode, SDVTList VTs, SDOperand N);
-  SDOperand getNode(unsigned Opcode, SDVTList VTs,
-                    SDOperand N1, SDOperand N2);
+  SDOperand getNode(unsigned Opcode, SDVTList VTs, SDOperand N1, SDOperand N2);
   SDOperand getNode(unsigned Opcode, SDVTList VTs,
                     SDOperand N1, SDOperand N2, SDOperand N3);
   SDOperand getNode(unsigned Opcode, SDVTList VTs,
@@ -340,7 +334,7 @@ public:
   /// getSetCC - Helper function to make it easier to build SetCC's if you just
   /// have an ISD::CondCode instead of an SDOperand.
   ///
-  SDOperand getSetCC(MVT::ValueType VT, SDOperand LHS, SDOperand RHS,
+  SDOperand getSetCC(MVT VT, SDOperand LHS, SDOperand RHS,
                      ISD::CondCode Cond) {
     return getNode(ISD::SETCC, VT, LHS, RHS, getCondCode(Cond));
   }
@@ -348,7 +342,7 @@ public:
   /// getVSetCC - Helper function to make it easier to build VSetCC's nodes
   /// if you just have an ISD::CondCode instead of an SDOperand.
   ///
-  SDOperand getVSetCC(MVT::ValueType VT, SDOperand LHS, SDOperand RHS,
+  SDOperand getVSetCC(MVT VT, SDOperand LHS, SDOperand RHS,
                       ISD::CondCode Cond) {
     return getNode(ISD::VSETCC, VT, LHS, RHS, getCondCode(Cond));
   }
@@ -364,35 +358,35 @@ public:
   
   /// getVAArg - VAArg produces a result and token chain, and takes a pointer
   /// and a source value as input.
-  SDOperand getVAArg(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
+  SDOperand getVAArg(MVT VT, SDOperand Chain, SDOperand Ptr,
                      SDOperand SV);
 
   /// getAtomic - Gets a node for an atomic op, produces result and chain, takes
   // 3 operands
   SDOperand getAtomic(unsigned Opcode, SDOperand Chain, SDOperand Ptr, 
-                      SDOperand Cmp, SDOperand Swp, MVT::ValueType VT);
+                      SDOperand Cmp, SDOperand Swp, MVT VT);
 
   /// getAtomic - Gets a node for an atomic op, produces result and chain, takes
   // 2 operands
   SDOperand getAtomic(unsigned Opcode, SDOperand Chain, SDOperand Ptr, 
-                      SDOperand Val, MVT::ValueType VT);
+                      SDOperand Val, MVT VT);
 
   /// getLoad - Loads are not normal binary operators: their result type is not
   /// determined by their operands, and they produce a value AND a token chain.
   ///
-  SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
+  SDOperand getLoad(MVT VT, SDOperand Chain, SDOperand Ptr,
                     const Value *SV, int SVOffset, bool isVolatile=false,
                     unsigned Alignment=0);
-  SDOperand getExtLoad(ISD::LoadExtType ExtType, MVT::ValueType VT,
+  SDOperand getExtLoad(ISD::LoadExtType ExtType, MVT VT,
                        SDOperand Chain, SDOperand Ptr, const Value *SV,
-                       int SVOffset, MVT::ValueType EVT, bool isVolatile=false,
+                       int SVOffset, MVT EVT, bool isVolatile=false,
                        unsigned Alignment=0);
   SDOperand getIndexedLoad(SDOperand OrigLoad, SDOperand Base,
                            SDOperand Offset, ISD::MemIndexedMode AM);
   SDOperand getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType,
-                    MVT::ValueType VT, SDOperand Chain,
+                    MVT VT, SDOperand Chain,
                     SDOperand Ptr, SDOperand Offset,
-                    const Value *SV, int SVOffset, MVT::ValueType EVT,
+                    const Value *SV, int SVOffset, MVT EVT,
                     bool isVolatile=false, unsigned Alignment=0);
 
   /// getStore - Helper function to build ISD::STORE nodes.
@@ -401,7 +395,7 @@ public:
                      const Value *SV, int SVOffset, bool isVolatile=false,
                      unsigned Alignment=0);
   SDOperand getTruncStore(SDOperand Chain, SDOperand Val, SDOperand Ptr,
-                          const Value *SV, int SVOffset, MVT::ValueType TVT,
+                          const Value *SV, int SVOffset, MVT TVT,
                           bool isVolatile=false, unsigned Alignment=0);
   SDOperand getIndexedStore(SDOperand OrigStoe, SDOperand Base,
                            SDOperand Offset, ISD::MemIndexedMode AM);
@@ -434,20 +428,18 @@ public:
   /// operands.  Note that target opcodes are stored as
   /// ISD::BUILTIN_OP_END+TargetOpcode in the node opcode field.  The 0th value
   /// of the resultant node is returned.
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1);
-  SDNode *SelectNodeTo(SDNode