Rename isOperand() to isOperandOf() (and other similar methods). It always confuses me.

[oota-llvm.git] / include / llvm / CodeGen / SelectionDAGNodes.h

diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index 56645f708eb64e70a88c8fb069108a42c9f1fc59..afd1e78d204e63343f9b9cf515359050d46bbad6 100644 (file)
--- 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.
@@ -824,8 +825,8 @@ 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.
   ///
@@ -968,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.
   ///