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
/// 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.
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;
/// 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.
///
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; }
SDOperand Ops[4];
MVT::ValueType OrigVT;
public:
- AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand X,
- SDOperand Y, SDOperand Z, MVT::ValueType VT)
+ AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand Ptr,
+ SDOperand Cmp, SDOperand Swp, MVT::ValueType VT)
: SDNode(Opc, VTL) {
Ops[0] = Chain;
- Ops[1] = X;
- Ops[2] = Y;
- Ops[3] = Z;
+ Ops[1] = Ptr;
+ Ops[2] = Swp;
+ Ops[3] = Cmp;
InitOperands(Ops, 4);
OrigVT=VT;
}
- AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand X,
- SDOperand Y, MVT::ValueType VT)
+ AtomicSDNode(unsigned Opc, SDVTList VTL, SDOperand Chain, SDOperand Ptr,
+ SDOperand Val, MVT::ValueType VT)
: SDNode(Opc, VTL) {
Ops[0] = Chain;
- Ops[1] = X;
- Ops[2] = Y;
+ 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 {
}
public:
- int getIndex() const { return JTI; }
+ int getIndex() const { return JTI; }
static bool classof(const JumpTableSDNode *) { return true; }
static bool classof(const SDNode *N) {
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);
"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; }
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) {
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) {
projects / oota-llvm.git / blobdiff