X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FSelectionDAGNodes.h;h=afd1e78d204e63343f9b9cf515359050d46bbad6;hb=917be6814e0a4e529d290be5d806a054bbbc4a27;hp=d47e0a69a7dd9d60614afb47f71c1930495a9d86;hpb=59a8cdd36d644fd5d0d7c78c3c02b31f1ba29a95;p=oota-llvm.git diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h index d47e0a69a7d..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. @@ -824,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; @@ -962,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. /// @@ -1011,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; } @@ -1620,12 +1633,17 @@ public: Ops[i] = Operands[i]; InitOperands(Ops, NumOperands); assert(Align != 0 && "Loads and stores should have non-zero aligment"); + assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) && + "Only indexed loads and stores have a non-undef offset operand"); } const SDOperand &getChain() const { return getOperand(0); } const SDOperand &getBasePtr() const { return getOperand(getOpcode() == ISD::LOAD ? 1 : 2); } + const SDOperand &getOffset() const { + return getOperand(getOpcode() == ISD::LOAD ? 2 : 3); + } const Value *getSrcValue() const { return SrcValue; } int getSrcValueOffset() const { return SVOffset; } @@ -1667,10 +1685,7 @@ 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) { - assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) && - "Only indexed loads and stores have a non-undef offset operand"); - } + ExtType(ETy) {} public: ISD::LoadExtType getExtensionType() const { return ExtType; } @@ -1697,10 +1712,7 @@ 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) { - assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) && - "Only indexed loads and stores have a non-undef offset operand"); - } + IsTruncStore(isTrunc) {} public: bool isTruncatingStore() const { return IsTruncStore; }