Ongoing work on improving the instruction selection infrastructure:

Rename SDOperandImpl back to SDOperand.
Introduce the SDUse class that represents a use of the SDNode referred by
an SDOperand. Now it is more similar to Use/Value classes.

Patch is approved by Dan Gohman.

llvm-svn: 49795

include/llvm/CodeGen/ScheduleDAG.h

@@ -334,7 +334,7 @@ namespace llvm {
     /// register number for the results of the node.
     ///
     void EmitNode(SDNode *Node, unsigned InstNo,
-                  DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+                  DenseMap<SDOperand, unsigned> &VRBaseMap);
     
     /// EmitNoop - Emit a noop instruction.
     ///
@@ -352,11 +352,11 @@ namespace llvm {
     /// EmitSubregNode - Generate machine code for subreg nodes.
     ///
     void EmitSubregNode(SDNode *Node, 
-                        DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+                        DenseMap<SDOperand, unsigned> &VRBaseMap);
 
     /// getVR - Return the virtual register corresponding to the specified result
     /// of the specified node.
-    unsigned getVR(SDOperand Op, DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+    unsigned getVR(SDOperand Op, DenseMap<SDOperand, unsigned> &VRBaseMap);
   
     /// getDstOfCopyToRegUse - If the only use of the specified result number of
     /// node is a CopyToReg, return its destination register. Return 0 otherwise.
@@ -364,7 +364,7 @@ namespace llvm {
 
     void AddOperand(MachineInstr *MI, SDOperand Op, unsigned IIOpNum,
                     const TargetInstrDesc *II,
-                    DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+                    DenseMap<SDOperand, unsigned> &VRBaseMap);
 
     void AddMemOperand(MachineInstr *MI, const MachineMemOperand &MO);
 
@@ -374,11 +374,11 @@ namespace llvm {
     /// implicit physical register output.
     void EmitCopyFromReg(SDNode *Node, unsigned ResNo, unsigned InstNo,
                          unsigned SrcReg,
-                         DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+                         DenseMap<SDOperand, unsigned> &VRBaseMap);
     
     void CreateVirtualRegisters(SDNode *Node, MachineInstr *MI,
                                 const TargetInstrDesc &II,
-                                DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
+                                DenseMap<SDOperand, unsigned> &VRBaseMap);
 
     /// EmitLiveInCopy - Emit a copy for a live in physical register. If the
     /// physical register has only a single copy use, then coalesced the copy

include/llvm/CodeGen/SelectionDAG.h

@@ -304,11 +304,11 @@ public:
                     SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4,
                     SDOperand N5);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
-                    const SDOperand *Ops, unsigned NumOps);
+                    SDOperandPtr Ops, unsigned NumOps);
   SDOperand getNode(unsigned Opcode, std::vector<MVT::ValueType> &ResultTys,
-                    const SDOperand *Ops, unsigned NumOps);
+                    SDOperandPtr Ops, unsigned NumOps);
   SDOperand getNode(unsigned Opcode, const MVT::ValueType *VTs, unsigned NumVTs,
-                    const SDOperand *Ops, unsigned NumOps);
+                    SDOperandPtr Ops, unsigned NumOps);
   SDOperand getNode(unsigned Opcode, SDVTList VTs);
   SDOperand getNode(unsigned Opcode, SDVTList VTs, SDOperand N);
   SDOperand getNode(unsigned Opcode, SDVTList VTs,
@@ -321,7 +321,7 @@ public:
                     SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4,
                     SDOperand N5);
   SDOperand getNode(unsigned Opcode, SDVTList VTs,
-                    const SDOperand *Ops, unsigned NumOps);
+                    SDOperandPtr Ops, unsigned NumOps);
 
   SDOperand getMemcpy(SDOperand Chain, SDOperand Dst, SDOperand Src,
                       SDOperand Size, unsigned Align,
@@ -420,7 +420,7 @@ public:
                                SDOperand Op3, SDOperand Op4);
   SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2,
                                SDOperand Op3, SDOperand Op4, SDOperand Op5);
-  SDOperand UpdateNodeOperands(SDOperand N, SDOperand *Ops, unsigned NumOps);
+  SDOperand UpdateNodeOperands(SDOperand N, SDOperandPtr Ops, unsigned NumOps);
   
   /// SelectNodeTo - These are used for target selectors to *mutate* the
   /// specified node to have the specified return type, Target opcode, and
@@ -435,7 +435,7 @@ public:
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
                        SDOperand Op1, SDOperand Op2, SDOperand Op3);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT,
-                        const SDOperand *Ops, unsigned NumOps);
+                       SDOperandPtr Ops, unsigned NumOps);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1, 
                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1,
@@ -457,7 +457,7 @@ public:
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
                         SDOperand Op1, SDOperand Op2, SDOperand Op3);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        const SDOperand *Ops, unsigned NumOps);
+                        SDOperandPtr Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
                         MVT::ValueType VT2);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
@@ -469,7 +469,7 @@ public:
                         SDOperand Op3);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                         MVT::ValueType VT2,
-                        const SDOperand *Ops, unsigned NumOps);
+                        SDOperandPtr Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
                         MVT::ValueType VT2, MVT::ValueType VT3,
                         SDOperand Op1, SDOperand Op2);
@@ -478,18 +478,18 @@ public:
                         SDOperand Op1, SDOperand Op2, SDOperand Op3);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                         MVT::ValueType VT2, MVT::ValueType VT3,
-                        const SDOperand *Ops, unsigned NumOps);
+                        SDOperandPtr Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                         MVT::ValueType VT2, MVT::ValueType VT3,
                         MVT::ValueType VT4,
-                        const SDOperand *Ops, unsigned NumOps);
+                        SDOperandPtr Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, std::vector<MVT::ValueType> &ResultTys,
-                        const SDOperand *Ops, unsigned NumOps);
+                        SDOperandPtr Ops, unsigned NumOps);
 
   /// getNodeIfExists - Get the specified node if it's already available, or
   /// else return NULL.
   SDNode *getNodeIfExists(unsigned Opcode, SDVTList VTs,
-                          const SDOperand *Ops, unsigned NumOps);
+                          SDOperandPtr Ops, unsigned NumOps);
   
   /// DAGUpdateListener - Clients of various APIs that cause global effects on
   /// the DAG can optionally implement this interface.  This allows the clients
@@ -519,7 +519,7 @@ public:
                           DAGUpdateListener *UpdateListener = 0);
   void ReplaceAllUsesWith(SDNode *From, SDNode *To,
                           DAGUpdateListener *UpdateListener = 0);
-  void ReplaceAllUsesWith(SDNode *From, const SDOperand *To,
+  void ReplaceAllUsesWith(SDNode *From, SDOperandPtr To,
                           DAGUpdateListener *UpdateListener = 0);
 
   /// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving
@@ -606,7 +606,7 @@ private:
   SDNode *FindModifiedNodeSlot(SDNode *N, SDOperand Op, void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDOperand Op1, SDOperand Op2,
                                void *&InsertPos);
-  SDNode *FindModifiedNodeSlot(SDNode *N, const SDOperand *Ops, unsigned NumOps,
+  SDNode *FindModifiedNodeSlot(SDNode *N, SDOperandPtr Ops, unsigned NumOps,
                                void *&InsertPos);
 
   void DeleteNodeNotInCSEMaps(SDNode *N);

include/llvm/CodeGen/SelectionDAGNodes.h

@@ -771,7 +771,7 @@ namespace ISD {
 
 
 //===----------------------------------------------------------------------===//
-/// SDOperandImpl - Unlike LLVM values, Selection DAG nodes may return multiple
+/// SDOperand - Unlike LLVM values, Selection DAG nodes may return multiple
 /// values as the result of a computation.  Many nodes return multiple values,
 /// from loads (which define a token and a return value) to ADDC (which returns
 /// a result and a carry value), to calls (which may return an arbitrary number
@@ -779,28 +779,28 @@ namespace ISD {
 ///
 /// As such, each use of a SelectionDAG computation must indicate the node that
 /// computes it as well as which return value to use from that node.  This pair
-/// of information is represented with the SDOperandImpl value type.
+/// of information is represented with the SDOperand value type.
 ///
-class SDOperandImpl {
+class SDOperand {
 public:
   SDNode *Val;        // The node defining the value we are using.
   unsigned ResNo;     // Which return value of the node we are using.
 
-  SDOperandImpl() : Val(0), ResNo(0) {}
+  SDOperand() : Val(0), ResNo(0) {}
-  SDOperandImpl(SDNode *val, unsigned resno) : Val(val), ResNo(resno) {}
+  SDOperand(SDNode *val, unsigned resno) : Val(val), ResNo(resno) {}
 
-  bool operator==(const SDOperandImpl &O) const {
+  bool operator==(const SDOperand &O) const {
     return Val == O.Val && ResNo == O.ResNo;
   }
-  bool operator!=(const SDOperandImpl &O) const {
+  bool operator!=(const SDOperand &O) const {
     return !operator==(O);
   }
-  bool operator<(const SDOperandImpl &O) const {
+  bool operator<(const SDOperand &O) const {
     return Val < O.Val || (Val == O.Val && ResNo < O.ResNo);
   }
 
-  SDOperandImpl getValue(unsigned R) const {
+  SDOperand getValue(unsigned R) const {
-    return SDOperandImpl(Val, R);
+    return SDOperand(Val, R);
   }
 
   // isOperandOf - Return true if this node is an operand of N.
@@ -819,7 +819,7 @@ public:
   // Forwarding methods - These forward to the corresponding methods in SDNode.
   inline unsigned getOpcode() const;
   inline unsigned getNumOperands() const;
-  inline const SDOperandImpl &getOperand(unsigned i) const;
+  inline const SDOperand &getOperand(unsigned i) const;
   inline uint64_t getConstantOperandVal(unsigned i) const;
   inline bool isTargetOpcode() const;
   inline unsigned getTargetOpcode() const;
@@ -830,7 +830,7 @@ public:
   /// side-effecting instructions.  In practice, this looks through token
   /// factors and non-volatile loads.  In order to remain efficient, this only
   /// looks a couple of nodes in, it does not do an exhaustive search.
-  bool reachesChainWithoutSideEffects(SDOperandImpl Dest, 
+  bool reachesChainWithoutSideEffects(SDOperand Dest, 
                                       unsigned Depth = 2) const;
   
   /// hasOneUse - Return true if there is exactly one operation using this
@@ -843,105 +843,23 @@ public:
 };
 
 
-template<> struct DenseMapInfo<SDOperandImpl> {
+template<> struct DenseMapInfo<SDOperand> {
-  static inline SDOperandImpl getEmptyKey() { 
+  static inline SDOperand getEmptyKey() { 
-    return SDOperandImpl((SDNode*)-1, -1U); 
+    return SDOperand((SDNode*)-1, -1U); 
   }
-  static inline SDOperandImpl getTombstoneKey() { 
+  static inline SDOperand getTombstoneKey() { 
-    return SDOperandImpl((SDNode*)-1, 0);
+    return SDOperand((SDNode*)-1, 0);
   }
-  static unsigned getHashValue(const SDOperandImpl &Val) {
+  static unsigned getHashValue(const SDOperand &Val) {
     return ((unsigned)((uintptr_t)Val.Val >> 4) ^
             (unsigned)((uintptr_t)Val.Val >> 9)) + Val.ResNo;
   }
-  static bool isEqual(const SDOperandImpl &LHS, const SDOperandImpl &RHS) {
+  static bool isEqual(const SDOperand &LHS, const SDOperand &RHS) {
     return LHS == RHS;
   }
   static bool isPod() { return true; }
 };
 
-/// simplify_type specializations - Allow casting operators to work directly on
-/// SDOperands as if they were SDNode*'s.
-template<> struct simplify_type<SDOperandImpl> {
-  typedef SDNode* SimpleType;
-  static SimpleType getSimplifiedValue(const SDOperandImpl &Val) {
-    return static_cast<SimpleType>(Val.Val);
-  }
-};
-template<> struct simplify_type<const SDOperandImpl> {
-  typedef SDNode* SimpleType;
-  static SimpleType getSimplifiedValue(const SDOperandImpl &Val) {
-    return static_cast<SimpleType>(Val.Val);
-  }
-};
-
-/// SDOperand - Represents a use of the SDNode referred by
-/// the SDOperandImpl.
-class SDOperand: public SDOperandImpl {
-  /// parent - Parent node of this operand.
-  SDNode    *parent;
-  /// Prev, next - Pointers to the uses list of the SDNode referred by 
-  /// this operand.
-  SDOperand **Prev, *Next;
-public:
-  friend class SDNode;
-  SDOperand(): SDOperandImpl(), parent(NULL), Prev(NULL), Next(NULL) {}
-
-  SDOperand(SDNode *val, unsigned resno) : 
-    SDOperandImpl(val,resno), parent(NULL), Prev(NULL), Next(NULL) {}
-
-  SDOperand(const SDOperandImpl& Op): SDOperandImpl(Op),parent(NULL),
-      Prev(NULL), Next(NULL)  {
-  }
-
-  SDOperand& operator= (SDOperandImpl& Op) {
-      *(SDOperandImpl*)this = Op;
-      Next = NULL;
-      Prev = NULL;
-      return *this;
-  }
-
-  SDOperand& operator= (const SDOperandImpl& Op) {
-      *(SDOperandImpl*)this = Op;
-      Next = NULL;
-      Prev = NULL;
-      return *this;
-  }
-
-  SDOperand& operator= (SDOperand& Op) {
-      *(SDOperandImpl*)this = Op;
-      Next = NULL;
-      Prev = NULL;
-      return *this;
-  }
-
-  SDOperand& operator= (const SDOperand& Op) {
-      *(SDOperandImpl*)this = Op;
-      Next = NULL;
-      Prev = NULL;
-      return *this;
-  }
-
-  SDOperand * getNext() { return Next; }
-
-  SDNode *getUser() { return parent; }
-  void setUser(SDNode *p) { parent = p; }
-
-protected:
-  void addToList(SDOperand **List) {
-    Next = *List;
-    if (Next) Next->Prev = &Next;
-    Prev = List;
-    *List = this;
-  }
-
-  void removeFromList() {
-    *Prev = Next;
-    if (Next) Next->Prev = Prev;
-  }
-};
-
-
 /// simplify_type specializations - Allow casting operators to work directly on
 /// SDOperands as if they were SDNode*'s.
 template<> struct simplify_type<SDOperand> {
@@ -957,6 +875,147 @@ template<> struct simplify_type<const SDOperand> {
   }
 };
 
+/// SDUse - Represents a use of the SDNode referred by
+/// the SDOperand.
+class SDUse {
+  SDOperand Operand;
+  /// parent - Parent node of this operand.
+  SDNode    *parent;
+  /// Prev, next - Pointers to the uses list of the SDNode referred by 
+  /// this operand.
+  SDUse **Prev, *Next;
+public:
+  friend class SDNode;
+  SDUse(): Operand(), parent(NULL), Prev(NULL), Next(NULL) {}
+
+  SDUse(SDNode *val, unsigned resno) : 
+    Operand(val,resno), parent(NULL), Prev(NULL), Next(NULL) {}
+
+
+  SDUse& operator= (SDOperand& Op) {
+      Operand = Op;
+      Next = NULL;
+      Prev = NULL;
+      return *this;
+  }
+
+  SDUse& operator= (const SDOperand& Op) {
+      Operand = Op;
+      Next = NULL;
+      Prev = NULL;
+      return *this;
+  }
+
+  SDUse& operator= (SDUse& Op) {
+      Operand = Op;
+      Next = NULL;
+      Prev = NULL;
+      return *this;
+  }
+
+  SDUse& operator= (const SDUse& Op) {
+      Operand = Op;
+      Next = NULL;
+      Prev = NULL;
+      return *this;
+  }
+
+  SDUse * getNext() { return Next; }
+
+  SDNode *getUser() { return parent; }
+
+  void setUser(SDNode *p) { parent = p; }
+
+  operator SDOperand() const { return Operand; }
+
+  const SDOperand& getSDOperand() const { return Operand; }
+
+  SDNode* &getVal () { return Operand.Val; }
+
+  bool operator==(const SDOperand &O) const {
+    return Operand == O;
+  }
+
+  bool operator!=(const SDOperand &O) const {
+    return !(Operand == O);
+  }
+
+  bool operator<(const SDOperand &O) const {
+    return Operand < O;
+  }
+
+protected:
+  void addToList(SDUse **List) {
+    Next = *List;
+    if (Next) Next->Prev = &Next;
+    Prev = List;
+    *List = this;
+  }
+
+  void removeFromList() {
+    *Prev = Next;
+    if (Next) Next->Prev = Prev;
+  }
+};
+
+
+/// simplify_type specializations - Allow casting operators to work directly on
+/// SDOperands as if they were SDNode*'s.
+template<> struct simplify_type<SDUse> {
+  typedef SDNode* SimpleType;
+  static SimpleType getSimplifiedValue(const SDUse &Val) {
+    return static_cast<SimpleType>(Val.getSDOperand().Val);
+  }
+};
+template<> struct simplify_type<const SDUse> {
+  typedef SDNode* SimpleType;
+  static SimpleType getSimplifiedValue(const SDUse &Val) {
+    return static_cast<SimpleType>(Val.getSDOperand().Val);
+  }
+};
+
+
+/// SDOperandPtr - A helper SDOperand poiner class, that can handle
+/// arrays of SDUse and arrays of SDOperand objects. This is required
+/// in many places inside the SelectionDAG.
+/// 
+class SDOperandPtr {
+  const SDOperand *ptr; // The pointer to the SDOperand object
+  int object_size;      // The size of the object containg the SDOperand
+public:
+  SDOperandPtr(SDUse * use_ptr) { 
+    ptr = &use_ptr->getSDOperand(); 
+    object_size = sizeof(SDUse); 
+  }
+
+  SDOperandPtr(const SDOperand * op_ptr) { 
+    ptr = op_ptr; 
+    object_size = sizeof(SDOperand); 
+  }
+
+  operator const SDOperand *() const {
+    assert(object_size == sizeof(SDOperand) && 
+           "Only SDOperand can be converted");
+    return ptr;
+  }
+
+  const SDOperand operator *() { return *ptr; }
+  const SDOperand *operator ->() { return ptr; }
+  SDOperandPtr operator ++ () { 
+    ptr = (SDOperand*)((char *)ptr + object_size); 
+    return *this; 
+  }
+
+  SDOperandPtr operator ++ (int) { 
+    SDOperandPtr tmp = *this;
+    ptr = (SDOperand*)((char *)ptr + object_size); 
+    return tmp; 
+  }
+
+  SDOperand operator[] (int idx) const {
+    return *(SDOperand*)((char*) ptr + object_size * idx);
+  } 
+};
 
 /// SDNode - Represents one node in the SelectionDAG.
 ///
@@ -975,7 +1034,7 @@ private:
 
   /// OperandList - The values that are used by this operation.
   ///
-  SDOperand *OperandList;
+  SDUse *OperandList;
   
   /// ValueList - The types of the values this node defines.  SDNode's may
   /// define multiple values simultaneously.
@@ -993,10 +1052,10 @@ private:
   unsigned UsesSize;
 
   /// Uses - List of uses for this SDNode.
-  SDOperand *Uses;
+  SDUse *Uses;
 
-  /// addUse - add SDOperand to the list of uses.
+  /// addUse - add SDUse to the list of uses.
-  void addUse(SDOperand &U) { U.addToList(&Uses); }
+  void addUse(SDUse &U) { U.addToList(&Uses); }
 
   // Out-of-line virtual method to give class a home.
   virtual void ANCHOR();
@@ -1027,17 +1086,17 @@ public:
   /// setNodeId - Set unique node id.
   void setNodeId(int Id) { NodeId = Id; }
 
-  /// use_iterator - This class provides iterator support for SDOperand
+  /// use_iterator - This class provides iterator support for SDUse
   /// operands that use a specific SDNode. 
   class use_iterator
-    : public forward_iterator<SDOperand, ptrdiff_t> {
+    : public forward_iterator<SDUse, ptrdiff_t> {
-    SDOperand *Op;
+    SDUse *Op;
-    explicit use_iterator(SDOperand *op) : Op(op) {
+    explicit use_iterator(SDUse *op) : Op(op) {
     }
     friend class SDNode;
   public:
-    typedef forward_iterator<SDOperand, ptrdiff_t>::reference reference;
+    typedef forward_iterator<SDUse, ptrdiff_t>::reference reference;
-    typedef forward_iterator<SDOperand, ptrdiff_t>::pointer pointer;
+    typedef forward_iterator<SDUse, ptrdiff_t>::pointer pointer;
 
     use_iterator(const use_iterator &I) : Op(I.Op) {}
     use_iterator() : Op(0) {}
@@ -1071,13 +1130,13 @@ public:
     }
 
     /// Retrieve a reference to the current operand.
-    SDOperand &operator*() const {
+    SDUse &operator*() const {
       assert(Op && "Cannot dereference end iterator!");
       return *Op;
     }
 
     /// Retrieve a pointer to the current operand.
-    SDOperand *operator->() const {
+    SDUse *operator->() const {
       assert(Op && "Cannot dereference end iterator!");
       return Op;
     }
@@ -1130,10 +1189,10 @@ public:
 
   const SDOperand &getOperand(unsigned Num) const {
     assert(Num < NumOperands && "Invalid child # of SDNode!");
-    return OperandList[Num];
+    return OperandList[Num].getSDOperand();
   }
 
-  typedef SDOperand* op_iterator;
+  typedef SDUse* op_iterator;
   op_iterator op_begin() const { return OperandList; }
   op_iterator op_end() const { return OperandList+NumOperands; }
 
@@ -1193,7 +1252,25 @@ protected:
     : NodeType(Opc), NodeId(-1), UsesSize(0), Uses(NULL) {
     OperandsNeedDelete = true;
     NumOperands = NumOps;
-    OperandList = NumOps ? new SDOperand[NumOperands] : 0;
+    OperandList = NumOps ? new SDUse[NumOperands] : 0;
+    
+    for (unsigned i = 0; i != NumOps; ++i) {
+      OperandList[i] = Ops[i];
+      OperandList[i].setUser(this);
+      Ops[i].Val->addUse(OperandList[i]);
+      ++Ops[i].Val->UsesSize;
+    }
+    
+    ValueList = VTs.VTs;
+    NumValues = VTs.NumVTs;
+    Prev = 0; Next = 0;
+  }
+
+  SDNode(unsigned Opc, SDVTList VTs, SDOperandPtr Ops, unsigned NumOps)
+    : NodeType(Opc), NodeId(-1), UsesSize(0), Uses(NULL) {
+    OperandsNeedDelete = true;
+    NumOperands = NumOps;
+    OperandList = NumOps ? new SDUse[NumOperands] : 0;
     
     for (unsigned i = 0; i != NumOps; ++i) {
       OperandList[i] = Ops[i];
@@ -1220,7 +1297,7 @@ protected:
   /// InitOperands - Initialize the operands list of this node with the
   /// specified values, which are part of the node (thus they don't need to be
   /// copied in or allocated).
-  void InitOperands(SDOperand *Ops, unsigned NumOps) {
+  void InitOperands(SDUse *Ops, unsigned NumOps) {
     assert(OperandList == 0 && "Operands already set!");
     NumOperands = NumOps;
     OperandList = Ops;
@@ -1229,8 +1306,8 @@ protected:
     
     for (unsigned i = 0; i != NumOps; ++i) {
       OperandList[i].setUser(this);
-      Ops[i].Val->addUse(OperandList[i]);
+      Ops[i].getVal()->addUse(OperandList[i]);
-      ++Ops[i].Val->UsesSize;
+      ++Ops[i].getVal()->UsesSize;
     }
   }
   
@@ -1248,40 +1325,40 @@ protected:
 
   void removeUser(unsigned i, SDNode *User) {
     assert(User->OperandList[i].getUser() && "Node without parent");
-    SDOperand &Op = User->OperandList[i];
+    SDUse &Op = User->OperandList[i];
     Op.removeFromList();
     --UsesSize;
   }
 };
 
 
-// Define inline functions from the SDOperandImpl class.
+// Define inline functions from the SDOperand class.
 
-inline unsigned SDOperandImpl::getOpcode() const {
+inline unsigned SDOperand::getOpcode() const {
   return Val->getOpcode();
 }
-inline MVT::ValueType SDOperandImpl::getValueType() const {
+inline MVT::ValueType SDOperand::getValueType() const {
   return Val->getValueType(ResNo);
 }
-inline unsigned SDOperandImpl::getNumOperands() const {
+inline unsigned SDOperand::getNumOperands() const {
   return Val->getNumOperands();
 }
-inline const SDOperandImpl &SDOperandImpl::getOperand(unsigned i) const {
+inline const SDOperand &SDOperand::getOperand(unsigned i) const {
   return Val->getOperand(i);
 }
-inline uint64_t SDOperandImpl::getConstantOperandVal(unsigned i) const {
+inline uint64_t SDOperand::getConstantOperandVal(unsigned i) const {
   return Val->getConstantOperandVal(i);
 }
-inline bool SDOperandImpl::isTargetOpcode() const {
+inline bool SDOperand::isTargetOpcode() const {
   return Val->isTargetOpcode();
 }
-inline unsigned SDOperandImpl::getTargetOpcode() const {
+inline unsigned SDOperand::getTargetOpcode() const {
   return Val->getTargetOpcode();
 }
-inline bool SDOperandImpl::hasOneUse() const {
+inline bool SDOperand::hasOneUse() const {
   return Val->hasNUsesOfValue(1, ResNo);
 }
-inline bool SDOperandImpl::use_empty() const {
+inline bool SDOperand::use_empty() const {
   return !Val->hasAnyUseOfValue(ResNo);
 }
 
@@ -1289,10 +1366,11 @@ inline bool SDOperandImpl::use_empty() const {
 /// to allow co-allocation of node operands with the node itself.
 class UnarySDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
-  SDOperand Op;
+  SDUse Op;
 public:
   UnarySDNode(unsigned Opc, SDVTList VTs, SDOperand X)
-    : SDNode(Opc, VTs), Op(X) {
+    : SDNode(Opc, VTs) {
+    Op = X;
     InitOperands(&Op, 1);
   }
 };
@@ -1301,7 +1379,7 @@ public:
 /// to allow co-allocation of node operands with the node itself.
 class BinarySDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
-  SDOperand Ops[2];
+  SDUse Ops[2];
 public:
   BinarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y)
     : SDNode(Opc, VTs) {
@@ -1315,7 +1393,7 @@ public:
 /// to allow co-allocation of node operands with the node itself.
 class TernarySDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
-  SDOperand Ops[3];
+  SDUse Ops[3];
 public:
   TernarySDNode(unsigned Opc, SDVTList VTs, SDOperand X, SDOperand Y,
                 SDOperand Z)
@@ -1334,19 +1412,20 @@ public:
 /// the AllNodes list.
 class HandleSDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
-  SDOperand Op;
+  SDUse Op;
 public:
   explicit HandleSDNode(SDOperand X)
-    : SDNode(ISD::HANDLENODE, getSDVTList(MVT::Other)), Op(X) {
+    : SDNode(ISD::HANDLENODE, getSDVTList(MVT::Other)) {
+    Op = X;
     InitOperands(&Op, 1);
   }
   ~HandleSDNode();  
-  SDOperand getValue() const { return Op; }
+  SDUse getValue() const { return Op; }
 };
 
 class AtomicSDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
-  SDOperand Ops[4];
+  SDUse Ops[4];
   MVT::ValueType OrigVT;
 public:
   AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand Ptr, 
@@ -1867,7 +1946,7 @@ protected:
     common functionality shared between LoadSDNode and
     StoreSDNode
    */
-  SDOperand Ops[4];
+  SDUse Ops[4];
 public:
   LSBaseSDNode(ISD::NodeType NodeTy, SDOperand *Operands, unsigned NumOperands,
                SDVTList VTs, ISD::MemIndexedMode AM, MVT::ValueType VT, 

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

@@ -3880,7 +3880,8 @@ SDOperand DAGCombiner::visitFP_EXTEND(SDNode *N) {
   MVT::ValueType VT = N->getValueType(0);
   
   // If this is fp_round(fpextend), don't fold it, allow ourselves to be folded.
-  if (N->hasOneUse() && (N->use_begin())->getOpcode() == ISD::FP_ROUND)
+  if (N->hasOneUse() && 
+      N->use_begin()->getSDOperand().getOpcode() == ISD::FP_ROUND)
     return SDOperand();
 
   // fold (fp_extend c1fp) -> c1fp

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

@@ -86,17 +86,17 @@ class VISIBILITY_HIDDEN SelectionDAGLegalize {
   /// LegalizedNodes - For nodes that are of legal width, and that have more
   /// than one use, this map indicates what regularized operand to use.  This
   /// allows us to avoid legalizing the same thing more than once.
-  DenseMap<SDOperandImpl, SDOperand> LegalizedNodes;
+  DenseMap<SDOperand, SDOperand> LegalizedNodes;
 
   /// PromotedNodes - For nodes that are below legal width, and that have more
   /// than one use, this map indicates what promoted value to use.  This allows
   /// us to avoid promoting the same thing more than once.
-  DenseMap<SDOperandImpl, SDOperand> PromotedNodes;
+  DenseMap<SDOperand, SDOperand> PromotedNodes;
 
   /// ExpandedNodes - For nodes that need to be expanded this map indicates
   /// which which operands are the expanded version of the input.  This allows
   /// us to avoid expanding the same node more than once.
-  DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> > ExpandedNodes;
+  DenseMap<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes;
 
   /// SplitNodes - For vector nodes that need to be split, this map indicates
   /// which which operands are the split version of the input.  This allows us
@@ -784,7 +784,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
 
   // Note that LegalizeOp may be reentered even from single-use nodes, which
   // means that we always must cache transformed nodes.
-  DenseMap<SDOperandImpl, SDOperand>::iterator I = LegalizedNodes.find(Op);
+  DenseMap<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op);
   if (I != LegalizedNodes.end()) return I->second;
 
   SDOperand Tmp1, Tmp2, Tmp3, Tmp4;
@@ -1600,7 +1600,7 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
     // will cause this node to be legalized as well as handling libcalls right.
     if (LastCALLSEQ_END.Val != Node) {
       LegalizeOp(SDOperand(FindCallStartFromCallEnd(Node), 0));
-      DenseMap<SDOperandImpl, SDOperand>::iterator I = LegalizedNodes.find(Op);
+      DenseMap<SDOperand, SDOperand>::iterator I = LegalizedNodes.find(Op);
       assert(I != LegalizedNodes.end() &&
              "Legalizing the call start should have legalized this node!");
       return I->second;
@@ -4016,7 +4016,7 @@ SDOperand SelectionDAGLegalize::PromoteOp(SDOperand Op) {
   SDOperand Result;
   SDNode *Node = Op.Val;
 
-  DenseMap<SDOperandImpl, SDOperand>::iterator I = PromotedNodes.find(Op);
+  DenseMap<SDOperand, SDOperand>::iterator I = PromotedNodes.find(Op);
   if (I != PromotedNodes.end()) return I->second;
 
   switch (Node->getOpcode()) {
@@ -5721,7 +5721,7 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
          "Cannot expand to FP value or to larger int value!");
 
   // See if we already expanded it.
-  DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> >::iterator I
+  DenseMap<SDOperand, std::pair<SDOperand, SDOperand> >::iterator I
     = ExpandedNodes.find(Op);
   if (I != ExpandedNodes.end()) {
     Lo = I->second.first;

lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

@@ -273,39 +273,39 @@ void DAGTypeLegalizer::SanityCheck(SDNode *N) {
        E = Worklist.end(); I != E; ++I)
     assert(*I != N);
 
-  for (DenseMap<SDOperandImpl, SDOperand>::iterator I = ReplacedNodes.begin(),
+  for (DenseMap<SDOperand, SDOperand>::iterator I = ReplacedNodes.begin(),
        E = ReplacedNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.Val != N);
   }
 
-  for (DenseMap<SDOperandImpl, SDOperand>::iterator I = PromotedNodes.begin(),
+  for (DenseMap<SDOperand, SDOperand>::iterator I = PromotedNodes.begin(),
        E = PromotedNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.Val != N);
   }
 
-  for (DenseMap<SDOperandImpl, SDOperand>::iterator
+  for (DenseMap<SDOperand, SDOperand>::iterator
        I = FloatToIntedNodes.begin(),
        E = FloatToIntedNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.Val != N);
   }
 
-  for (DenseMap<SDOperandImpl, SDOperand>::iterator I = ScalarizedNodes.begin(),
+  for (DenseMap<SDOperand, SDOperand>::iterator I = ScalarizedNodes.begin(),
        E = ScalarizedNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.Val != N);
   }
 
-  for (DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> >::iterator
+  for (DenseMap<SDOperand, std::pair<SDOperand, SDOperand> >::iterator
        I = ExpandedNodes.begin(), E = ExpandedNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.first.Val != N);
     assert(I->second.second.Val != N);
   }
 
-  for (DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> >::iterator
+  for (DenseMap<SDOperand, std::pair<SDOperand, SDOperand> >::iterator
        I = SplitNodes.begin(), E = SplitNodes.end(); I != E; ++I) {
     assert(I->first.Val != N);
     assert(I->second.first.Val != N);
@@ -393,7 +393,7 @@ void DAGTypeLegalizer::ReplaceNodeWith(SDNode *From, SDNode *To) {
 /// RemapNode - If the specified value was already legalized to another value,
 /// replace it by that value.
 void DAGTypeLegalizer::RemapNode(SDOperand &N) {
-  DenseMap<SDOperandImpl, SDOperand>::iterator I = ReplacedNodes.find(N);
+  DenseMap<SDOperand, SDOperand>::iterator I = ReplacedNodes.find(N);
   if (I != ReplacedNodes.end()) {
     // Use path compression to speed up future lookups if values get multiply
     // replaced with other values.

lib/CodeGen/SelectionDAG/LegalizeTypes.h

@@ -110,27 +110,27 @@ private:
 
   /// PromotedNodes - For nodes that are below legal width, this map indicates
   /// what promoted value to use.
-  DenseMap<SDOperandImpl, SDOperand> PromotedNodes;
+  DenseMap<SDOperand, SDOperand> PromotedNodes;
   
   /// ExpandedNodes - For nodes that need to be expanded this map indicates
   /// which operands are the expanded version of the input.
-  DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> > ExpandedNodes;
+  DenseMap<SDOperand, std::pair<SDOperand, SDOperand> > ExpandedNodes;
 
   /// FloatToIntedNodes - For floating point nodes converted to integers of
   /// the same size, this map indicates the converted value to use.
-  DenseMap<SDOperandImpl, SDOperand> FloatToIntedNodes;
+  DenseMap<SDOperand, SDOperand> FloatToIntedNodes;
 
   /// ScalarizedNodes - For nodes that are <1 x ty>, this map indicates the
   /// scalar value of type 'ty' to use.
-  DenseMap<SDOperandImpl, SDOperand> ScalarizedNodes;
+  DenseMap<SDOperand, SDOperand> ScalarizedNodes;
 
   /// SplitNodes - For nodes that need to be split this map indicates
   /// which operands are the expanded version of the input.
-  DenseMap<SDOperandImpl, std::pair<SDOperand, SDOperand> > SplitNodes;
+  DenseMap<SDOperand, std::pair<SDOperand, SDOperand> > SplitNodes;
   
   /// ReplacedNodes - For nodes that have been replaced with another,
   /// indicates the replacement node to use.
-  DenseMap<SDOperandImpl, SDOperand> ReplacedNodes;
+  DenseMap<SDOperand, SDOperand> ReplacedNodes;
 
   /// Worklist - This defines a worklist of nodes to process.  In order to be
   /// pushed onto this worklist, all operands of a node must have already been

lib/CodeGen/SelectionDAG/ScheduleDAG.cpp

@@ -400,7 +400,7 @@ static const TargetRegisterClass *getInstrOperandRegClass(
 
 void ScheduleDAG::EmitCopyFromReg(SDNode *Node, unsigned ResNo,
                                   unsigned InstanceNo, unsigned SrcReg,
-                                  DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                                  DenseMap<SDOperand, unsigned> &VRBaseMap) {
   unsigned VRBase = 0;
   if (TargetRegisterInfo::isVirtualRegister(SrcReg)) {
     // Just use the input register directly!
@@ -488,7 +488,7 @@ unsigned ScheduleDAG::getDstOfOnlyCopyToRegUse(SDNode *Node,
 
 void ScheduleDAG::CreateVirtualRegisters(SDNode *Node, MachineInstr *MI,
                                  const TargetInstrDesc &II,
-                                 DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                                 DenseMap<SDOperand, unsigned> &VRBaseMap) {
   assert(Node->getTargetOpcode() != TargetInstrInfo::IMPLICIT_DEF &&
          "IMPLICIT_DEF should have been handled as a special case elsewhere!");
 
@@ -529,7 +529,7 @@ void ScheduleDAG::CreateVirtualRegisters(SDNode *Node, MachineInstr *MI,
 /// getVR - Return the virtual register corresponding to the specified result
 /// of the specified node.
 unsigned ScheduleDAG::getVR(SDOperand Op,
-                            DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                            DenseMap<SDOperand, unsigned> &VRBaseMap) {
   if (Op.isTargetOpcode() &&
       Op.getTargetOpcode() == TargetInstrInfo::IMPLICIT_DEF) {
     // Add an IMPLICIT_DEF instruction before every use.
@@ -544,7 +544,7 @@ unsigned ScheduleDAG::getVR(SDOperand Op,
     return VReg;
   }
 
-  DenseMap<SDOperandImpl, unsigned>::iterator I = VRBaseMap.find(Op);
+  DenseMap<SDOperand, unsigned>::iterator I = VRBaseMap.find(Op);
   assert(I != VRBaseMap.end() && "Node emitted out of order - late");
   return I->second;
 }
@@ -557,7 +557,7 @@ unsigned ScheduleDAG::getVR(SDOperand Op,
 void ScheduleDAG::AddOperand(MachineInstr *MI, SDOperand Op,
                              unsigned IIOpNum,
                              const TargetInstrDesc *II,
-                             DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                             DenseMap<SDOperand, unsigned> &VRBaseMap) {
   if (Op.isTargetOpcode()) {
     // Note that this case is redundant with the final else block, but we
     // include it because it is the most common and it makes the logic
@@ -688,7 +688,7 @@ static const TargetRegisterClass *getSuperregRegisterClass(
 /// EmitSubregNode - Generate machine code for subreg nodes.
 ///
 void ScheduleDAG::EmitSubregNode(SDNode *Node, 
-                           DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                           DenseMap<SDOperand, unsigned> &VRBaseMap) {
   unsigned VRBase = 0;
   unsigned Opc = Node->getTargetOpcode();
   
@@ -779,7 +779,7 @@ void ScheduleDAG::EmitSubregNode(SDNode *Node,
 /// EmitNode - Generate machine code for an node and needed dependencies.
 ///
 void ScheduleDAG::EmitNode(SDNode *Node, unsigned InstanceNo,
-                           DenseMap<SDOperandImpl, unsigned> &VRBaseMap) {
+                           DenseMap<SDOperand, unsigned> &VRBaseMap) {
   // If machine instruction
   if (Node->isTargetOpcode()) {
     unsigned Opc = Node->getTargetOpcode();
@@ -1102,7 +1102,7 @@ void ScheduleDAG::EmitSchedule() {
   }
 
   // Finally, emit the code for all of the scheduled instructions.
-  DenseMap<SDOperandImpl, unsigned> VRBaseMap;
+  DenseMap<SDOperand, unsigned> VRBaseMap;
   DenseMap<SUnit*, unsigned> CopyVRBaseMap;
   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
     SUnit *SU = Sequence[i];

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

@@ -328,7 +328,7 @@ void AddNodeIDValueTypes(FoldingSetNodeID &ID, SDVTList VTList) {
 /// AddNodeIDOperands - Various routines for adding operands to the NodeID data.
 ///
 static void AddNodeIDOperands(FoldingSetNodeID &ID,
-                              const SDOperand *Ops, unsigned NumOps) {
+                              SDOperandPtr Ops, unsigned NumOps) {
   for (; NumOps; --NumOps, ++Ops) {
     ID.AddPointer(Ops->Val);
     ID.AddInteger(Ops->ResNo);
@@ -343,6 +343,7 @@ static void AddNodeIDNode(FoldingSetNodeID &ID,
   AddNodeIDOperands(ID, OpList, N);
 }
 
+
 /// AddNodeIDNode - Generic routine for adding a nodes info to the NodeID
 /// data.
 static void AddNodeIDNode(FoldingSetNodeID &ID, SDNode *N) {
@@ -464,7 +465,7 @@ void SelectionDAG::RemoveDeadNodes() {
     // Next, brutally remove the operand list.  This is safe to do, as there are
     // no cycles in the graph.
     for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
-      SDNode *Operand = I->Val;
+      SDNode *Operand = I->getVal();
       Operand->removeUser(std::distance(N->op_begin(), I), N);
       
       // Now that we removed this operand, see if there are no uses of it left.
@@ -504,7 +505,7 @@ void SelectionDAG::RemoveDeadNode(SDNode *N, DAGUpdateListener *UpdateListener){
     // Next, brutally remove the operand list.  This is safe to do, as there are
     // no cycles in the graph.
     for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
-      SDNode *Operand = I->Val;
+      SDNode *Operand = I->getVal();
       Operand->removeUser(std::distance(N->op_begin(), I), N);
       
       // Now that we removed this operand, see if there are no uses of it left.
@@ -540,7 +541,7 @@ void SelectionDAG::DeleteNodeNotInCSEMaps(SDNode *N) {
     
   // Drop all of the operands and decrement used nodes use counts.
   for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I)
-    I->Val->removeUser(std::distance(N->op_begin(), I), N);
+    I->getVal()->removeUser(std::distance(N->op_begin(), I), N);
   if (N->OperandsNeedDelete) {
     delete[] N->OperandList;
   }
@@ -669,7 +670,7 @@ SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N,
 /// return null, otherwise return a pointer to the slot it would take.  If a
 /// node already exists with these operands, the slot will be non-null.
 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, 
-                                           const SDOperand *Ops,unsigned NumOps,
+                                           SDOperandPtr Ops,unsigned NumOps,
                                            void *&InsertPos) {
   if (N->getOpcode() == ISD::HANDLENODE || N->getValueType(0) == MVT::Flag)
     return 0;    // Never add these nodes.
@@ -748,7 +749,7 @@ SDOperand SelectionDAG::getConstant(const APInt &Val, MVT::ValueType VT, bool is
 
   unsigned Opc = isT ? ISD::TargetConstant : ISD::Constant;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(EltVT), (SDOperand*)0, 0);
   ID.Add(Val);
   void *IP = 0;
   SDNode *N = NULL;
@@ -787,7 +788,7 @@ SDOperand SelectionDAG::getConstantFP(const APFloat& V, MVT::ValueType VT,
   // we don't have issues with SNANs.
   unsigned Opc = isTarget ? ISD::TargetConstantFP : ISD::ConstantFP;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(EltVT), (SDOperand*)0, 0);
   ID.Add(V);
   void *IP = 0;
   SDNode *N = NULL;
@@ -837,7 +838,7 @@ SDOperand SelectionDAG::getGlobalAddress(const GlobalValue *GV,
     Opc = isTargetGA ? ISD::TargetGlobalAddress : ISD::GlobalAddress;
 
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(VT), (SDOperand*)0, 0);
   ID.AddPointer(GV);
   ID.AddInteger(Offset);
   void *IP = 0;
@@ -853,7 +854,7 @@ SDOperand SelectionDAG::getFrameIndex(int FI, MVT::ValueType VT,
                                       bool isTarget) {
   unsigned Opc = isTarget ? ISD::TargetFrameIndex : ISD::FrameIndex;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(VT), (SDOperand*)0, 0);
   ID.AddInteger(FI);
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
@@ -867,7 +868,7 @@ SDOperand SelectionDAG::getFrameIndex(int FI, MVT::ValueType VT,
 SDOperand SelectionDAG::getJumpTable(int JTI, MVT::ValueType VT, bool isTarget){
   unsigned Opc = isTarget ? ISD::TargetJumpTable : ISD::JumpTable;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(VT), (SDOperand*)0, 0);
   ID.AddInteger(JTI);
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
@@ -883,7 +884,7 @@ SDOperand SelectionDAG::getConstantPool(Constant *C, MVT::ValueType VT,
                                         bool isTarget) {
   unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(VT), (SDOperand*)0, 0);
   ID.AddInteger(Alignment);
   ID.AddInteger(Offset);
   ID.AddPointer(C);
@@ -903,7 +904,7 @@ SDOperand SelectionDAG::getConstantPool(MachineConstantPoolValue *C,
                                         bool isTarget) {
   unsigned Opc = isTarget ? ISD::TargetConstantPool : ISD::ConstantPool;
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opc, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opc, getVTList(VT), (SDOperand*)0, 0);
   ID.AddInteger(Alignment);
   ID.AddInteger(Offset);
   C->AddSelectionDAGCSEId(ID);
@@ -919,7 +920,7 @@ SDOperand SelectionDAG::getConstantPool(MachineConstantPoolValue *C,
 
 SDOperand SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), 0, 0);
+  AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), (SDOperand*)0, 0);
   ID.AddPointer(MBB);
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
@@ -932,7 +933,7 @@ SDOperand SelectionDAG::getBasicBlock(MachineBasicBlock *MBB) {
 
 SDOperand SelectionDAG::getArgFlags(ISD::ArgFlagsTy Flags) {
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::ARG_FLAGS, getVTList(MVT::Other), 0, 0);
+  AddNodeIDNode(ID, ISD::ARG_FLAGS, getVTList(MVT::Other), (SDOperand*)0, 0);
   ID.AddInteger(Flags.getRawBits());
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
@@ -986,7 +987,7 @@ SDOperand SelectionDAG::getCondCode(ISD::CondCode Cond) {
 
 SDOperand SelectionDAG::getRegister(unsigned RegNo, MVT::ValueType VT) {
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::Register, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, ISD::Register, getVTList(VT), (SDOperand*)0, 0);
   ID.AddInteger(RegNo);
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
@@ -1002,7 +1003,7 @@ SDOperand SelectionDAG::getSrcValue(const Value *V) {
          "SrcValue is not a pointer?");
 
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::SRCVALUE, getVTList(MVT::Other), 0, 0);
+  AddNodeIDNode(ID, ISD::SRCVALUE, getVTList(MVT::Other), (SDOperand*)0, 0);
   ID.AddPointer(V);
 
   void *IP = 0;
@@ -1021,7 +1022,7 @@ SDOperand SelectionDAG::getMemOperand(const MachineMemOperand &MO) {
          "SrcValue is not a pointer?");
 
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::MEMOPERAND, getVTList(MVT::Other), 0, 0);
+  AddNodeIDNode(ID, ISD::MEMOPERAND, getVTList(MVT::Other), (SDOperand*)0, 0);
   ID.AddPointer(v);
   ID.AddInteger(MO.getFlags());
   ID.AddInteger(MO.getOffset());
@@ -1751,7 +1752,7 @@ bool SelectionDAG::isVerifiedDebugInfoDesc(SDOperand Op) const {
 ///
 SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT) {
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, Opcode, getVTList(VT), 0, 0);
+  AddNodeIDNode(ID, Opcode, getVTList(VT), (SDOperand*)0, 0);
   void *IP = 0;
   if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
     return SDOperand(E, 0);
@@ -2987,7 +2988,7 @@ SDOperand SelectionDAG::getVAArg(MVT::ValueType VT,
 }
 
 SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
-                                const SDOperand *Ops, unsigned NumOps) {
+                                SDOperandPtr Ops, unsigned NumOps) {
   switch (NumOps) {
   case 0: return getNode(Opcode, VT);
   case 1: return getNode(Opcode, VT, Ops[0]);
@@ -3036,21 +3037,21 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
 
 SDOperand SelectionDAG::getNode(unsigned Opcode,
                                 std::vector<MVT::ValueType> &ResultTys,
-                                const SDOperand *Ops, unsigned NumOps) {
+                                SDOperandPtr Ops, unsigned NumOps) {
   return getNode(Opcode, getNodeValueTypes(ResultTys), ResultTys.size(),
                  Ops, NumOps);
 }
 
 SDOperand SelectionDAG::getNode(unsigned Opcode,
                                 const MVT::ValueType *VTs, unsigned NumVTs,
-                                const SDOperand *Ops, unsigned NumOps) {
+                                SDOperandPtr Ops, unsigned NumOps) {
   if (NumVTs == 1)
     return getNode(Opcode, VTs[0], Ops, NumOps);
   return getNode(Opcode, makeVTList(VTs, NumVTs), Ops, NumOps);
 }  
   
 SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
-                                const SDOperand *Ops, unsigned NumOps) {
+                                SDOperandPtr Ops, unsigned NumOps) {
   if (VTList.NumVTs == 1)
     return getNode(Opcode, VTList.VTs[0], Ops, NumOps);
 
@@ -3109,7 +3110,7 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
 }
 
 SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList) {
-  return getNode(Opcode, VTList, 0, 0);
+  return getNode(Opcode, VTList, (SDOperand*)0, 0);
 }
 
 SDOperand SelectionDAG::getNode(unsigned Opcode, SDVTList VTList,
@@ -3228,7 +3229,7 @@ UpdateNodeOperands(SDOperand InN, SDOperand Op) {
     RemoveNodeFromCSEMaps(N);
   
   // Now we update the operands.
-  N->OperandList[0].Val->removeUser(0, N);
+  N->OperandList[0].getVal()->removeUser(0, N);
   N->OperandList[0] = Op;
   N->OperandList[0].setUser(N);
   Op.Val->addUser(0, N);
@@ -3258,13 +3259,13 @@ UpdateNodeOperands(SDOperand InN, SDOperand Op1, SDOperand Op2) {
   
   // Now we update the operands.
   if (N->OperandList[0] != Op1) {
-    N->OperandList[0].Val->removeUser(0, N);
+    N->OperandList[0].getVal()->removeUser(0, N);
     N->OperandList[0] = Op1;
     N->OperandList[0].setUser(N);
     Op1.Val->addUser(0, N);
   }
   if (N->OperandList[1] != Op2) {
-    N->OperandList[1].Val->removeUser(1, N);
+    N->OperandList[1].getVal()->removeUser(1, N);
     N->OperandList[1] = Op2;
     N->OperandList[1].setUser(N);
     Op2.Val->addUser(1, N);
@@ -3296,7 +3297,7 @@ UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2,
 }
 
 SDOperand SelectionDAG::
-UpdateNodeOperands(SDOperand InN, SDOperand *Ops, unsigned NumOps) {
+UpdateNodeOperands(SDOperand InN, SDOperandPtr Ops, unsigned NumOps) {
   SDNode *N = InN.Val;
   assert(N->getNumOperands() == NumOps &&
          "Update with wrong number of operands");
@@ -3325,7 +3326,7 @@ UpdateNodeOperands(SDOperand InN, SDOperand *Ops, unsigned NumOps) {
   // Now we update the operands.
   for (unsigned i = 0; i != NumOps; ++i) {
     if (N->OperandList[i] != Ops[i]) {
-      N->OperandList[i].Val->removeUser(i, N);
+      N->OperandList[i].getVal()->removeUser(i, N);
       N->OperandList[i] = Ops[i];
       N->OperandList[i].setUser(N);
       Ops[i].Val->addUser(i, N);
@@ -3349,7 +3350,7 @@ void SDNode::MorphNodeTo(unsigned Opc, SDVTList L,
   // Clear the operands list, updating used nodes to remove this from their
   // use list.
   for (op_iterator I = op_begin(), E = op_end(); I != E; ++I)
-    I->Val->removeUser(std::distance(op_begin(), I), this);
+    I->getVal()->removeUser(std::distance(op_begin(), I), this);
   
   // If NumOps is larger than the # of operands we currently have, reallocate
   // the operand list.
@@ -3357,7 +3358,7 @@ void SDNode::MorphNodeTo(unsigned Opc, SDVTList L,
     if (OperandsNeedDelete) {
       delete [] OperandList;
     }
-    OperandList = new SDOperand[NumOps];
+    OperandList = new SDUse[NumOps];
     OperandsNeedDelete = true;
   }
   
@@ -3367,7 +3368,7 @@ void SDNode::MorphNodeTo(unsigned Opc, SDVTList L,
   for (unsigned i = 0, e = NumOps; i != e; ++i) {
     OperandList[i] = Ops[i];
     OperandList[i].setUser(this);
-    SDNode *N = OperandList[i].Val;
+    SDNode *N = OperandList[i].getVal();
     N->addUser(i, this);
     ++N->UsesSize;
   }
@@ -3385,7 +3386,7 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
                                    MVT::ValueType VT) {
   SDVTList VTs = getVTList(VT);
   FoldingSetNodeID ID;
-  AddNodeIDNode(ID, ISD::BUILTIN_OP_END+TargetOpc, VTs, 0, 0);
+  AddNodeIDNode(ID, ISD::BUILTIN_OP_END+TargetOpc, VTs, (SDOperand*)0, 0);
   void *IP = 0;
   if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
     return ON;
@@ -3458,7 +3459,7 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
 }
 
 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, const SDOperand *Ops,
+                                   MVT::ValueType VT, SDOperandPtr Ops,
                                    unsigned NumOps) {
   // If an identical node already exists, use it.
   SDVTList VTs = getVTList(VT);
@@ -3536,7 +3537,7 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
   return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3).Val;
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    const SDOperand *Ops, unsigned NumOps) {
+                                    SDOperandPtr Ops, unsigned NumOps) {
   return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops, NumOps).Val;
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
@@ -3566,7 +3567,7 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                                     MVT::ValueType VT2,
-                                    const SDOperand *Ops, unsigned NumOps) {
+                                    SDOperandPtr Ops, unsigned NumOps) {
   const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
   return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, NumOps).Val;
 }
@@ -3587,14 +3588,14 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                                     MVT::ValueType VT2, MVT::ValueType VT3,
-                                    const SDOperand *Ops, unsigned NumOps) {
+                                    SDOperandPtr Ops, unsigned NumOps) {
   const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2, VT3);
   return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, NumOps).Val;
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
                                     MVT::ValueType VT2, MVT::ValueType VT3,
                                     MVT::ValueType VT4,
-                                    const SDOperand *Ops, unsigned NumOps) {
+                                    SDOperandPtr Ops, unsigned NumOps) {
   std::vector<MVT::ValueType> VTList;
   VTList.push_back(VT1);
   VTList.push_back(VT2);
@@ -3605,7 +3606,7 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode,
                                     std::vector<MVT::ValueType> &ResultTys,
-                                    const SDOperand *Ops, unsigned NumOps) {
+                                    SDOperandPtr Ops, unsigned NumOps) {
   const MVT::ValueType *VTs = getNodeValueTypes(ResultTys);
   return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, ResultTys.size(),
                  Ops, NumOps).Val;
@@ -3614,7 +3615,7 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode,
 /// getNodeIfExists - Get the specified node if it's already available, or
 /// else return NULL.
 SDNode *SelectionDAG::getNodeIfExists(unsigned Opcode, SDVTList VTList,
-                                      const SDOperand *Ops, unsigned NumOps) {
+                                      SDOperandPtr Ops, unsigned NumOps) {
   if (VTList.VTs[VTList.NumVTs-1] != MVT::Flag) {
     FoldingSetNodeID ID;
     AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
@@ -3647,7 +3648,7 @@ void SelectionDAG::ReplaceAllUsesWith(SDOperand FromN, SDOperand To,
     int operandNum = 0;
     for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
          I != E; ++I, ++operandNum)
-      if (I->Val == From) {
+      if (I->getVal() == From) {
         From->removeUser(operandNum, U);
         *I = To;
         I->setUser(U);
@@ -3695,9 +3696,9 @@ void SelectionDAG::ReplaceAllUsesWith(SDNode *From, SDNode *To,
     int operandNum = 0;
     for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
          I != E; ++I, ++operandNum)
-      if (I->Val == From) {
+      if (I->getVal() == From) {
         From->removeUser(operandNum, U);
-        I->Val = To;
+        I->getVal() = To;
         To->addUser(operandNum, U);
       }
 
@@ -3724,7 +3725,7 @@ void SelectionDAG::ReplaceAllUsesWith(SDNode *From, SDNode *To,
 /// This version can replace From with any result values.  To must match the
 /// number and types of values returned by From.
 void SelectionDAG::ReplaceAllUsesWith(SDNode *From,
-                                      const SDOperand *To,
+                                      SDOperandPtr To,
                                       DAGUpdateListener *UpdateListener) {
   if (From->getNumValues() == 1)  // Handle the simple case efficiently.
     return ReplaceAllUsesWith(SDOperand(From, 0), To[0], UpdateListener);
@@ -3738,8 +3739,8 @@ void SelectionDAG::ReplaceAllUsesWith(SDNode *From,
     int operandNum = 0;
     for (SDNode::op_iterator I = U->op_begin(), E = U->op_end();
          I != E; ++I, ++operandNum)
-      if (I->Val == From) {
+      if (I->getVal() == From) {
-        const SDOperand &ToOp = To[I->ResNo];
+        const SDOperand &ToOp = To[I->getSDOperand().ResNo];
         From->removeUser(operandNum, U);
         *I = ToOp;
         I->setUser(U);
@@ -3865,7 +3866,6 @@ void SelectionDAG::ReplaceAllUsesOfValueWith(SDOperand From, SDOperand To,
   }
 }
 
-
 /// AssignNodeIds - Assign a unique node id for each node in the DAG based on
 /// their allnodes order. It returns the maximum id.
 unsigned SelectionDAG::AssignNodeIds() {
@@ -3902,7 +3902,7 @@ unsigned SelectionDAG::AssignTopologicalOrder(std::vector<SDNode*> &TopOrder) {
     Sources.pop_back();
     TopOrder.push_back(N);
     for (SDNode::op_iterator I = N->op_begin(), E = N->op_end(); I != E; ++I) {
-      SDNode *P = I->Val;
+      SDNode *P = I->getVal();
       unsigned Degree = --InDegree[P->getNodeId()];
       if (Degree == 0)
         Sources.push_back(P);
@@ -4077,7 +4077,7 @@ bool SDNode::isOnlyUseOf(SDNode *N) const {
 
 /// isOperand - Return true if this node is an operand of N.
 ///
-bool SDOperandImpl::isOperandOf(SDNode *N) const {
+bool SDOperand::isOperandOf(SDNode *N) const {
   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
     if (*this == N->getOperand(i))
       return true;
@@ -4086,7 +4086,7 @@ bool SDOperandImpl::isOperandOf(SDNode *N) const {
 
 bool SDNode::isOperandOf(SDNode *N) const {
   for (unsigned i = 0, e = N->NumOperands; i != e; ++i)
-    if (this == N->OperandList[i].Val)
+    if (this == N->OperandList[i].getVal())
       return true;
   return false;
 }
@@ -4096,7 +4096,7 @@ bool SDNode::isOperandOf(SDNode *N) const {
 /// side-effecting instructions.  In practice, this looks through token
 /// factors and non-volatile loads.  In order to remain efficient, this only
 /// looks a couple of nodes in, it does not do an exhaustive search.
-bool SDOperandImpl::reachesChainWithoutSideEffects(SDOperandImpl Dest, 
+bool SDOperand::reachesChainWithoutSideEffects(SDOperand Dest, 
                                                unsigned Depth) const {
   if (*this == Dest) return true;
   

lib/Target/X86/X86ISelLowering.cpp

@@ -2094,7 +2094,7 @@ bool X86::isPSHUFLWMask(SDNode *N) {
 
 /// isSHUFPMask - Return true if the specified VECTOR_SHUFFLE operand
 /// specifies a shuffle of elements that is suitable for input to SHUFP*.
-static bool isSHUFPMask(const SDOperand *Elems, unsigned NumElems) {
+static bool isSHUFPMask(SDOperandPtr Elems, unsigned NumElems) {
   if (NumElems != 2 && NumElems != 4) return false;
 
   unsigned Half = NumElems / 2;
@@ -2117,7 +2117,7 @@ bool X86::isSHUFPMask(SDNode *N) {
 /// the reverse of what x86 shuffles want. x86 shuffles requires the lower
 /// half elements to come from vector 1 (which would equal the dest.) and
 /// the upper half to come from vector 2.
-static bool isCommutedSHUFP(const SDOperand *Ops, unsigned NumOps) {
+static bool isCommutedSHUFP(SDOperandPtr Ops, unsigned NumOps) {
   if (NumOps != 2 && NumOps != 4) return false;
 
   unsigned Half = NumOps / 2;
@@ -2211,7 +2211,7 @@ bool X86::isMOVHPMask(SDNode *N) {
 
 /// isUNPCKLMask - Return true if the specified VECTOR_SHUFFLE operand
 /// specifies a shuffle of elements that is suitable for input to UNPCKL.
-bool static isUNPCKLMask(const SDOperand *Elts, unsigned NumElts,
+bool static isUNPCKLMask(SDOperandPtr Elts, unsigned NumElts,
                          bool V2IsSplat = false) {
   if (NumElts != 2 && NumElts != 4 && NumElts != 8 && NumElts != 16)
     return false;
@@ -2240,7 +2240,7 @@ bool X86::isUNPCKLMask(SDNode *N, bool V2IsSplat) {
 
 /// isUNPCKHMask - Return true if the specified VECTOR_SHUFFLE operand
 /// specifies a shuffle of elements that is suitable for input to UNPCKH.
-bool static isUNPCKHMask(const SDOperand *Elts, unsigned NumElts,
+bool static isUNPCKHMask(SDOperandPtr Elts, unsigned NumElts,
                          bool V2IsSplat = false) {
   if (NumElts != 2 && NumElts != 4 && NumElts != 8 && NumElts != 16)
     return false;
@@ -2316,7 +2316,7 @@ bool X86::isUNPCKH_v_undef_Mask(SDNode *N) {
 /// isMOVLMask - Return true if the specified VECTOR_SHUFFLE operand
 /// specifies a shuffle of elements that is suitable for input to MOVSS,
 /// MOVSD, and MOVD, i.e. setting the lowest element.
-static bool isMOVLMask(const SDOperand *Elts, unsigned NumElts) {
+static bool isMOVLMask(SDOperandPtr Elts, unsigned NumElts) {
   if (NumElts != 2 && NumElts != 4)
     return false;
 
@@ -2339,7 +2339,7 @@ bool X86::isMOVLMask(SDNode *N) {
 /// isCommutedMOVL - Returns true if the shuffle mask is except the reverse
 /// of what x86 movss want. X86 movs requires the lowest  element to be lowest
 /// element of vector 2 and the other elements to come from vector 1 in order.
-static bool isCommutedMOVL(const SDOperand *Ops, unsigned NumOps,
+static bool isCommutedMOVL(SDOperandPtr Ops, unsigned NumOps,
                            bool V2IsSplat = false,
                            bool V2IsUndef = false) {
   if (NumOps != 2 && NumOps != 4 && NumOps != 8 && NumOps != 16)