X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FSelectionDAGNodes.h;h=afd1e78d204e63343f9b9cf515359050d46bbad6;hb=917be6814e0a4e529d290be5d806a054bbbc4a27;hp=4f56b9b5534b04b7f0709e81b85bb7c6d1ff9518;hpb=f504eefb6e5bdd72d59dff605719cdae53919ebf;p=oota-llvm.git

diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index 4f56b9b5534..afd1e78d204 100644
--- a/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -283,7 +283,8 @@ namespace ISD {
     BUILD_VECTOR,
     
     /// INSERT_VECTOR_ELT(VECTOR, VAL, IDX) - Returns VECTOR with the element
-    /// at IDX replaced with VAL.
+    /// at IDX replaced with VAL.  If the type of VAL is larger than the vector
+    /// element type then VAL is truncated before replacement.
     INSERT_VECTOR_ELT,
 
     /// EXTRACT_VECTOR_ELT(VECTOR, IDX) - Returns a single element from VECTOR
@@ -300,16 +301,16 @@ namespace ISD {
     /// vector value) starting with the (potentially variable) element number
     /// IDX, which must be a multiple of the result vector length.
     EXTRACT_SUBVECTOR,
-    
+
     /// VECTOR_SHUFFLE(VEC1, VEC2, SHUFFLEVEC) - Returns a vector, of the same
     /// type as VEC1/VEC2.  SHUFFLEVEC is a BUILD_VECTOR of constant int values
-    /// (regardless of whether its datatype is legal or not) that indicate
-    /// which value each result element will get.  The elements of VEC1/VEC2 are
-    /// enumerated in order.  This is quite similar to the Altivec 'vperm'
-    /// instruction, except that the indices must be constants and are in terms
-    /// of the element size of VEC1/VEC2, not in terms of bytes.
+    /// (maybe of an illegal datatype) or undef that indicate which value each
+    /// result element will get.  The elements of VEC1/VEC2 are enumerated in
+    /// order.  This is quite similar to the Altivec 'vperm' instruction, except
+    /// that the indices must be constants and are in terms of the element size
+    /// of VEC1/VEC2, not in terms of bytes.
     VECTOR_SHUFFLE,
-    
+
     /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a
     /// scalar value into element 0 of the resultant vector type.  The top
     /// elements 1 to N-1 of the N-element vector are undefined.
@@ -441,7 +442,7 @@ namespace ISD {
     // is added / subtracted from the base pointer to form the address (for
     // indexed memory ops).
     LOAD, STORE,
-    
+
     // DYNAMIC_STACKALLOC - Allocate some number of bytes on the stack aligned
     // to a specified boundary.  This node always has two return values: a new
     // stack pointer value and a chain. The first operand is the token chain,
@@ -589,6 +590,32 @@ namespace ISD {
     // TRAP - Trapping instruction
     TRAP,
 
+    // OUTCHAIN = MEMBARRIER(INCHAIN, load-load, load-store, store-load, 
+    //                       store-store, device)
+    // This corresponds to the memory.barrier intrinsic.
+    // it takes an input chain, 4 operands to specify the type of barrier, an
+    // operand specifying if the barrier applies to device and uncached memory
+    // and produces an output chain.
+    MEMBARRIER,
+
+    // Val, OUTCHAIN = ATOMIC_LCS(INCHAIN, ptr, cmp, swap)
+    // this corresponds to the atomic.lcs intrinsic.
+    // cmp is compared to *ptr, and if equal, swap is stored in *ptr.
+    // the return is always the original value in *ptr
+    ATOMIC_LCS,
+
+    // Val, OUTCHAIN = ATOMIC_LAS(INCHAIN, ptr, amt)
+    // this corresponds to the atomic.las intrinsic.
+    // *ptr + amt is stored to *ptr atomically.
+    // the return is always the original value in *ptr
+    ATOMIC_LAS,
+
+    // Val, OUTCHAIN = ATOMIC_SWAP(INCHAIN, ptr, amt)
+    // this corresponds to the atomic.swap intrinsic.
+    // amt is stored to *ptr atomically.
+    // the return is always the original value in *ptr
+    ATOMIC_SWAP,
+
     // BUILTIN_OP_END - This must be the last enum value in this list.
     BUILTIN_OP_END
   };
@@ -603,6 +630,11 @@ namespace ISD {
   /// BUILD_VECTOR where all of the elements are 0 or undef.
   bool isBuildVectorAllZeros(const SDNode *N);
 
+  /// isScalarToVector - Return true if the specified node is a
+  /// ISD::SCALAR_TO_VECTOR node or a BUILD_VECTOR node where only the low
+  /// element is not an undef.
+  bool isScalarToVector(const SDNode *N);
+
   /// isDebugLabel - Return true if the specified node represents a debug
   /// label (i.e. ISD::LABEL or TargetInstrInfo::LABEL node and third operand
   /// is 0).
@@ -793,13 +825,19 @@ public:
     return SDOperand(Val, R);
   }
 
-  // isOperand - Return true if this node is an operand of N.
-  bool isOperand(SDNode *N) const;
+  // isOperandOf - Return true if this node is an operand of N.
+  bool isOperandOf(SDNode *N) const;
 
   /// getValueType - Return the ValueType of the referenced return value.
   ///
   inline MVT::ValueType getValueType() const;
 
+  /// getValueSizeInBits - Returns MVT::getSizeInBits(getValueType()).
+  ///
+  unsigned getValueSizeInBits() const {
+    return MVT::getSizeInBits(getValueType());
+  }
+
   // Forwarding methods - These forward to the corresponding methods in SDNode.
   inline unsigned getOpcode() const;
   inline unsigned getNumOperands() const;
@@ -830,8 +868,8 @@ template<> struct DenseMapInfo<SDOperand> {
   static inline SDOperand getEmptyKey() { return SDOperand((SDNode*)-1, -1U); }
   static inline SDOperand getTombstoneKey() { return SDOperand((SDNode*)-1, 0);}
   static unsigned getHashValue(const SDOperand &Val) {
-    return (unsigned)((uintptr_t)Val.Val >> 4) ^
-           (unsigned)((uintptr_t)Val.Val >> 9) + Val.ResNo;
+    return ((unsigned)((uintptr_t)Val.Val >> 4) ^
+            (unsigned)((uintptr_t)Val.Val >> 9)) + Val.ResNo;
   }
   static bool isEqual(const SDOperand &LHS, const SDOperand &RHS) {
     return LHS == RHS;
@@ -931,19 +969,19 @@ public:
   /// value. This method ignores uses of other values defined by this operation.
   bool hasAnyUseOfValue(unsigned Value) const;
 
-  /// isOnlyUse - Return true if this node is the only use of N.
+  /// isOnlyUseOf - Return true if this node is the only use of N.
   ///
-  bool isOnlyUse(SDNode *N) const;
+  bool isOnlyUseOf(SDNode *N) const;
 
-  /// isOperand - Return true if this node is an operand of N.
+  /// isOperandOf - Return true if this node is an operand of N.
   ///
-  bool isOperand(SDNode *N) const;
+  bool isOperandOf(SDNode *N) const;
 
-  /// isPredecessor - Return true if this node is a predecessor of N. This node
-  /// is either an operand of N or it can be reached by recursively traversing
-  /// up the operands.
+  /// isPredecessorOf - Return true if this node is a predecessor of N. This
+  /// node is either an operand of N or it can be reached by recursively
+  /// traversing up the operands.
   /// NOTE: this is an expensive method. Use it carefully.
-  bool isPredecessor(SDNode *N) const;
+  bool isPredecessorOf(SDNode *N) const;
 
   /// getNumOperands - Return the number of values used by this operation.
   ///
@@ -980,6 +1018,12 @@ public:
     return ValueList[ResNo];
   }
 
+  /// getValueSizeInBits - Returns MVT::getSizeInBits(getValueType(ResNo)).
+  ///
+  unsigned getValueSizeInBits(unsigned ResNo) const {
+    return MVT::getSizeInBits(getValueType(ResNo));
+  }
+
   typedef const MVT::ValueType* value_iterator;
   value_iterator value_begin() const { return ValueList; }
   value_iterator value_end() const { return ValueList+NumValues; }
@@ -1157,6 +1201,34 @@ public:
   SDOperand getValue() const { return Op; }
 };
 
+class AtomicSDNode : public SDNode {
+  virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
+  SDOperand Ops[4];
+  MVT::ValueType OrigVT;
+public:
+  AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand Ptr, 
+               SDOperand Cmp, SDOperand Swp, MVT::ValueType VT)
+    : SDNode(Opc, VTL) {
+    Ops[0] = Chain;
+    Ops[1] = Ptr;
+    Ops[2] = Swp;
+    Ops[3] = Cmp;
+    InitOperands(Ops, 4);
+    OrigVT=VT;
+  }
+  AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand Ptr, 
+               SDOperand Val, MVT::ValueType VT)
+    : SDNode(Opc, VTL) {
+    Ops[0] = Chain;
+    Ops[1] = Ptr;
+    Ops[2] = Val;
+    InitOperands(Ops, 3);
+    OrigVT=VT;
+  }
+  MVT::ValueType getVT() const { return OrigVT; }
+  bool isCompareAndSwap() const { return getOpcode() == ISD::ATOMIC_LCS; }
+};
+
 class StringSDNode : public SDNode {
   std::string Value;
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
@@ -1294,7 +1366,7 @@ protected:
   }
 public:
     
-    int getIndex() const { return JTI; }
+  int getIndex() const { return JTI; }
   
   static bool classof(const JumpTableSDNode *) { return true; }
   static bool classof(const SDNode *N) {
@@ -1556,8 +1628,7 @@ public:
                const Value *SV, int SVO, unsigned Align, bool Vol)
     : SDNode(NodeTy, VTs),
       AddrMode(AM), MemoryVT(VT),
-      SrcValue(SV), SVOffset(SVO), Alignment(Align), IsVolatile(Vol)
-  {
+      SrcValue(SV), SVOffset(SVO), Alignment(Align), IsVolatile(Vol) {
     for (unsigned i = 0; i != NumOperands; ++i)
       Ops[i] = Operands[i];
     InitOperands(Ops, NumOperands);
@@ -1566,19 +1637,13 @@ public:
            "Only indexed loads and stores have a non-undef offset operand");
   }
 
-  const SDOperand getChain() const {
-    return getOperand(0);
-  }
-  const SDOperand getBasePtr() const {
+  const SDOperand &getChain() const { return getOperand(0); }
+  const SDOperand &getBasePtr() const {
     return getOperand(getOpcode() == ISD::LOAD ? 1 : 2);
   }
-  const SDOperand getOffset() const {
+  const SDOperand &getOffset() const {
     return getOperand(getOpcode() == ISD::LOAD ? 2 : 3);
   }
-  const SDOperand getValue() const {
-    assert(getOpcode() == ISD::STORE);
-    return getOperand(1);
-  }
 
   const Value *getSrcValue() const { return SrcValue; }
   int getSrcValueOffset() const { return SVOffset; }
@@ -1620,10 +1685,12 @@ protected:
              const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
     : LSBaseSDNode(ISD::LOAD, ChainPtrOff, 3,
                    VTs, AM, LVT, SV, O, Align, Vol),
-      ExtType(ETy) { }
+      ExtType(ETy) {}
 public:
 
   ISD::LoadExtType getExtensionType() const { return ExtType; }
+  const SDOperand &getBasePtr() const { return getOperand(1); }
+  const SDOperand &getOffset() const { return getOperand(2); }
   
   static bool classof(const LoadSDNode *) { return true; }
   static bool classof(const SDNode *N) {
@@ -1645,10 +1712,13 @@ protected:
               const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
     : LSBaseSDNode(ISD::STORE, ChainValuePtrOff, 4,
                    VTs, AM, SVT, SV, O, Align, Vol),
-      IsTruncStore(isTrunc) { }
+      IsTruncStore(isTrunc) {}
 public:
 
   bool isTruncatingStore() const { return IsTruncStore; }
+  const SDOperand &getValue() const { return getOperand(1); }
+  const SDOperand &getBasePtr() const { return getOperand(2); }
+  const SDOperand &getOffset() const { return getOperand(3); }
   
   static bool classof(const StoreSDNode *) { return true; }
   static bool classof(const SDNode *N) {