diff options
Diffstat (limited to 'include/llvm/CodeGen/SelectionDAG.h')
| -rw-r--r-- | include/llvm/CodeGen/SelectionDAG.h | 354 |
1 files changed, 177 insertions, 177 deletions
diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h index fee46b32a6..692d9027c5 100644 --- a/include/llvm/CodeGen/SelectionDAG.h +++ b/include/llvm/CodeGen/SelectionDAG.h @@ -52,7 +52,7 @@ class SelectionDAG { MachineModuleInfo *MMI; /// Root - The root of the entire DAG. EntryNode - The starting token. - SDOperand Root, EntryNode; + SDValue Root, EntryNode; /// AllNodes - A linked list of nodes in the current DAG. alist<SDNode, LargestSDNode> &AllNodes; @@ -120,15 +120,15 @@ public: /// getRoot - Return the root tag of the SelectionDAG. /// - const SDOperand &getRoot() const { return Root; } + const SDValue &getRoot() const { return Root; } /// getEntryNode - Return the token chain corresponding to the entry of the /// function. - const SDOperand &getEntryNode() const { return EntryNode; } + const SDValue &getEntryNode() const { return EntryNode; } /// setRoot - Set the current root tag of the SelectionDAG. /// - const SDOperand &setRoot(SDOperand N) { + const SDValue &setRoot(SDValue N) { assert((!N.Val || N.getValueType() == MVT::Other) && "DAG root value is not a chain!"); return Root = N; @@ -188,61 +188,61 @@ public: //===--------------------------------------------------------------------===// // Node creation methods. // - SDOperand getConstant(uint64_t Val, MVT VT, bool isTarget = false); - SDOperand getConstant(const APInt &Val, MVT VT, bool isTarget = false); - SDOperand getIntPtrConstant(uint64_t Val, bool isTarget = false); - SDOperand getTargetConstant(uint64_t Val, MVT VT) { + SDValue getConstant(uint64_t Val, MVT VT, bool isTarget = false); + SDValue getConstant(const APInt &Val, MVT VT, bool isTarget = false); + SDValue getIntPtrConstant(uint64_t Val, bool isTarget = false); + SDValue getTargetConstant(uint64_t Val, MVT VT) { return getConstant(Val, VT, true); } - SDOperand getTargetConstant(const APInt &Val, MVT VT) { + SDValue getTargetConstant(const APInt &Val, MVT VT) { return getConstant(Val, VT, true); } - SDOperand getConstantFP(double Val, MVT VT, bool isTarget = false); - SDOperand getConstantFP(const APFloat& Val, MVT VT, bool isTarget = false); - SDOperand getTargetConstantFP(double Val, MVT VT) { + SDValue getConstantFP(double Val, MVT VT, bool isTarget = false); + SDValue getConstantFP(const APFloat& Val, MVT VT, bool isTarget = false); + SDValue getTargetConstantFP(double Val, MVT VT) { return getConstantFP(Val, VT, true); } - SDOperand getTargetConstantFP(const APFloat& Val, MVT VT) { + SDValue getTargetConstantFP(const APFloat& Val, MVT VT) { return getConstantFP(Val, VT, true); } - SDOperand getGlobalAddress(const GlobalValue *GV, MVT VT, + SDValue getGlobalAddress(const GlobalValue *GV, MVT VT, int offset = 0, bool isTargetGA = false); - SDOperand getTargetGlobalAddress(const GlobalValue *GV, MVT VT, + SDValue getTargetGlobalAddress(const GlobalValue *GV, MVT VT, int offset = 0) { return getGlobalAddress(GV, VT, offset, true); } - SDOperand getFrameIndex(int FI, MVT VT, bool isTarget = false); - SDOperand getTargetFrameIndex(int FI, MVT VT) { + SDValue getFrameIndex(int FI, MVT VT, bool isTarget = false); + SDValue getTargetFrameIndex(int FI, MVT VT) { return getFrameIndex(FI, VT, true); } - SDOperand getJumpTable(int JTI, MVT VT, bool isTarget = false); - SDOperand getTargetJumpTable(int JTI, MVT VT) { + SDValue getJumpTable(int JTI, MVT VT, bool isTarget = false); + SDValue getTargetJumpTable(int JTI, MVT VT) { return getJumpTable(JTI, VT, true); } - SDOperand getConstantPool(Constant *C, MVT VT, + SDValue getConstantPool(Constant *C, MVT VT, unsigned Align = 0, int Offs = 0, bool isT=false); - SDOperand getTargetConstantPool(Constant *C, MVT VT, + SDValue getTargetConstantPool(Constant *C, MVT VT, unsigned Align = 0, int Offset = 0) { return getConstantPool(C, VT, Align, Offset, true); } - SDOperand getConstantPool(MachineConstantPoolValue *C, MVT VT, + SDValue getConstantPool(MachineConstantPoolValue *C, MVT VT, unsigned Align = 0, int Offs = 0, bool isT=false); - SDOperand getTargetConstantPool(MachineConstantPoolValue *C, + SDValue getTargetConstantPool(MachineConstantPoolValue *C, MVT VT, unsigned Align = 0, int Offset = 0) { return getConstantPool(C, VT, Align, Offset, true); } - SDOperand getBasicBlock(MachineBasicBlock *MBB); - SDOperand getExternalSymbol(const char *Sym, MVT VT); - SDOperand getTargetExternalSymbol(const char *Sym, MVT VT); - SDOperand getArgFlags(ISD::ArgFlagsTy Flags); - SDOperand getValueType(MVT); - SDOperand getRegister(unsigned Reg, MVT VT); - SDOperand getDbgStopPoint(SDOperand Root, unsigned Line, unsigned Col, + SDValue getBasicBlock(MachineBasicBlock *MBB); + SDValue getExternalSymbol(const char *Sym, MVT VT); + SDValue getTargetExternalSymbol(const char *Sym, MVT VT); + SDValue getArgFlags(ISD::ArgFlagsTy Flags); + SDValue getValueType(MVT); + SDValue getRegister(unsigned Reg, MVT VT); + SDValue getDbgStopPoint(SDValue Root, unsigned Line, unsigned Col, const CompileUnitDesc *CU); - SDOperand getLabel(unsigned Opcode, SDOperand Root, unsigned LabelID); + SDValue getLabel(unsigned Opcode, SDValue Root, unsigned LabelID); - SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N) { + SDValue getCopyToReg(SDValue Chain, unsigned Reg, SDValue N) { return getNode(ISD::CopyToReg, MVT::Other, Chain, getRegister(Reg, N.getValueType()), N); } @@ -250,57 +250,57 @@ public: // This version of the getCopyToReg method takes an extra operand, which // indicates that there is potentially an incoming flag value (if Flag is not // null) and that there should be a flag result. - SDOperand getCopyToReg(SDOperand Chain, unsigned Reg, SDOperand N, - SDOperand Flag) { + SDValue getCopyToReg(SDValue Chain, unsigned Reg, SDValue N, + SDValue Flag) { const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag); - SDOperand Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Flag }; + SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Flag }; return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3); } - // Similar to last getCopyToReg() except parameter Reg is a SDOperand - SDOperand getCopyToReg(SDOperand Chain, SDOperand Reg, SDOperand N, - SDOperand Flag) { + // Similar to last getCopyToReg() except parameter Reg is a SDValue + SDValue getCopyToReg(SDValue Chain, SDValue Reg, SDValue N, + SDValue Flag) { const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag); - SDOperand Ops[] = { Chain, Reg, N, Flag }; + SDValue Ops[] = { Chain, Reg, N, Flag }; return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3); } - SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT VT) { + SDValue getCopyFromReg(SDValue Chain, unsigned Reg, MVT VT) { const MVT *VTs = getNodeValueTypes(VT, MVT::Other); - SDOperand Ops[] = { Chain, getRegister(Reg, VT) }; + SDValue Ops[] = { Chain, getRegister(Reg, VT) }; return getNode(ISD::CopyFromReg, VTs, 2, Ops, 2); } // This version of the getCopyFromReg method takes an extra operand, which // indicates that there is potentially an incoming flag value (if Flag is not // null) and that there should be a flag result. - SDOperand getCopyFromReg(SDOperand Chain, unsigned Reg, MVT VT, - SDOperand Flag) { + SDValue getCopyFromReg(SDValue Chain, unsigned Reg, MVT VT, + SDValue Flag) { const MVT *VTs = getNodeValueTypes(VT, MVT::Other, MVT::Flag); - SDOperand Ops[] = { Chain, getRegister(Reg, VT), Flag }; + SDValue Ops[] = { Chain, getRegister(Reg, VT), Flag }; return getNode(ISD::CopyFromReg, VTs, 3, Ops, Flag.Val ? 3 : 2); } - SDOperand getCondCode(ISD::CondCode Cond); + SDValue getCondCode(ISD::CondCode Cond); /// getZeroExtendInReg - Return the expression required to zero extend the Op /// value assuming it was the smaller SrcTy value. - SDOperand getZeroExtendInReg(SDOperand Op, MVT SrcTy); + SDValue getZeroExtendInReg(SDValue Op, MVT SrcTy); /// getCALLSEQ_START - Return a new CALLSEQ_START node, which always must have /// a flag result (to ensure it's not CSE'd). - SDOperand getCALLSEQ_START(SDOperand Chain, SDOperand Op) { + SDValue getCALLSEQ_START(SDValue Chain, SDValue Op) { const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag); - SDOperand Ops[] = { Chain, Op }; + SDValue Ops[] = { Chain, Op }; return getNode(ISD::CALLSEQ_START, VTs, 2, Ops, 2); } /// getCALLSEQ_END - Return a new CALLSEQ_END node, which always must have a /// flag result (to ensure it's not CSE'd). - SDOperand getCALLSEQ_END(SDOperand Chain, SDOperand Op1, SDOperand Op2, - SDOperand InFlag) { + SDValue getCALLSEQ_END(SDValue Chain, SDValue Op1, SDValue Op2, + SDValue InFlag) { SDVTList NodeTys = getVTList(MVT::Other, MVT::Flag); - SmallVector<SDOperand, 4> Ops; + SmallVector<SDValue, 4> Ops; Ops.push_back(Chain); Ops.push_back(Op1); Ops.push_back(Op2); @@ -311,103 +311,103 @@ public: /// getNode - Gets or creates the specified node. /// - SDOperand getNode(unsigned Opcode, MVT VT); - SDOperand getNode(unsigned Opcode, MVT VT, SDOperand N); - SDOperand getNode(unsigned Opcode, MVT VT, SDOperand N1, SDOperand N2); - SDOperand getNode(unsigned Opcode, MVT VT, - SDOperand N1, SDOperand N2, SDOperand N3); - SDOperand getNode(unsigned Opcode, MVT VT, - SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4); - SDOperand getNode(unsigned Opcode, MVT VT, - SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4, - SDOperand N5); - SDOperand getNode(unsigned Opcode, MVT VT, - const SDOperand *Ops, unsigned NumOps); - SDOperand getNode(unsigned Opcode, MVT VT, + SDValue getNode(unsigned Opcode, MVT VT); + SDValue getNode(unsigned Opcode, MVT VT, SDValue N); + SDValue getNode(unsigned Opcode, MVT VT, SDValue N1, SDValue N2); + SDValue getNode(unsigned Opcode, MVT VT, + SDValue N1, SDValue N2, SDValue N3); + SDValue getNode(unsigned Opcode, MVT VT, + SDValue N1, SDValue N2, SDValue N3, SDValue N4); + SDValue getNode(unsigned Opcode, MVT VT, + SDValue N1, SDValue N2, SDValue N3, SDValue N4, + SDValue N5); + SDValue getNode(unsigned Opcode, MVT VT, + const SDValue *Ops, unsigned NumOps); + SDValue getNode(unsigned Opcode, MVT VT, const SDUse *Ops, unsigned NumOps); - SDOperand getNode(unsigned Opcode, const std::vector<MVT> &ResultTys, - const SDOperand *Ops, unsigned NumOps); - SDOperand getNode(unsigned Opcode, const MVT *VTs, unsigned NumVTs, - const SDOperand *Ops, unsigned NumOps); - SDOperand getNode(unsigned Opcode, SDVTList VTs); - SDOperand getNode(unsigned Opcode, SDVTList VTs, SDOperand N); - SDOperand getNode(unsigned Opcode, SDVTList VTs, SDOperand N1, SDOperand N2); - SDOperand getNode(unsigned Opcode, SDVTList VTs, - SDOperand N1, SDOperand N2, SDOperand N3); - SDOperand getNode(unsigned Opcode, SDVTList VTs, - SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4); - SDOperand getNode(unsigned Opcode, SDVTList VTs, - SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4, - SDOperand N5); - SDOperand getNode(unsigned Opcode, SDVTList VTs, - const SDOperand *Ops, unsigned NumOps); - - SDOperand getMemcpy(SDOperand Chain, SDOperand Dst, SDOperand Src, - SDOperand Size, unsigned Align, + SDValue getNode(unsigned Opcode, const std::vector<MVT> &ResultTys, + const SDValue *Ops, unsigned NumOps); + SDValue getNode(unsigned Opcode, const MVT *VTs, unsigned NumVTs, + const SDValue *Ops, unsigned NumOps); + SDValue getNode(unsigned Opcode, SDVTList VTs); + SDValue getNode(unsigned Opcode, SDVTList VTs, SDValue N); + SDValue getNode(unsigned Opcode, SDVTList VTs, SDValue N1, SDValue N2); + SDValue getNode(unsigned Opcode, SDVTList VTs, + SDValue N1, SDValue N2, SDValue N3); + SDValue getNode(unsigned Opcode, SDVTList VTs, + SDValue N1, SDValue N2, SDValue N3, SDValue N4); + SDValue getNode(unsigned Opcode, SDVTList VTs, + SDValue N1, SDValue N2, SDValue N3, SDValue N4, + SDValue N5); + SDValue getNode(unsigned Opcode, SDVTList VTs, + const SDValue *Ops, unsigned NumOps); + + SDValue getMemcpy(SDValue Chain, SDValue Dst, SDValue Src, + SDValue Size, unsigned Align, bool AlwaysInline, const Value *DstSV, uint64_t DstSVOff, const Value *SrcSV, uint64_t SrcSVOff); - SDOperand getMemmove(SDOperand Chain, SDOperand Dst, SDOperand Src, - SDOperand Size, unsigned Align, + SDValue getMemmove(SDValue Chain, SDValue Dst, SDValue Src, + SDValue Size, unsigned Align, const Value *DstSV, uint64_t DstOSVff, const Value *SrcSV, uint64_t SrcSVOff); - SDOperand getMemset(SDOperand Chain, SDOperand Dst, SDOperand Src, - SDOperand Size, unsigned Align, + SDValue getMemset(SDValue Chain, SDValue Dst, SDValue Src, + SDValue Size, unsigned Align, const Value *DstSV, uint64_t DstSVOff); /// getSetCC - Helper function to make it easier to build SetCC's if you just - /// have an ISD::CondCode instead of an SDOperand. + /// have an ISD::CondCode instead of an SDValue. /// - SDOperand getSetCC(MVT VT, SDOperand LHS, SDOperand RHS, + SDValue getSetCC(MVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond) { return getNode(ISD::SETCC, VT, LHS, RHS, getCondCode(Cond)); } /// getVSetCC - Helper function to make it easier to build VSetCC's nodes - /// if you just have an ISD::CondCode instead of an SDOperand. + /// if you just have an ISD::CondCode instead of an SDValue. /// - SDOperand getVSetCC(MVT VT, SDOperand LHS, SDOperand RHS, + SDValue getVSetCC(MVT VT, SDValue LHS, SDValue RHS, ISD::CondCode Cond) { return getNode(ISD::VSETCC, VT, LHS, RHS, getCondCode(Cond)); } /// getSelectCC - Helper function to make it easier to build SelectCC's if you - /// just have an ISD::CondCode instead of an SDOperand. + /// just have an ISD::CondCode instead of an SDValue. /// - SDOperand getSelectCC(SDOperand LHS, SDOperand RHS, - SDOperand True, SDOperand False, ISD::CondCode Cond) { + SDValue getSelectCC(SDValue LHS, SDValue RHS, + SDValue True, SDValue False, ISD::CondCode Cond) { return getNode(ISD::SELECT_CC, True.getValueType(), LHS, RHS, True, False, getCondCode(Cond)); } /// getVAArg - VAArg produces a result and token chain, and takes a pointer /// and a source value as input. - SDOperand getVAArg(MVT VT, SDOperand Chain, SDOperand Ptr, - SDOperand SV); + SDValue getVAArg(MVT VT, SDValue Chain, SDValue Ptr, + SDValue SV); /// getAtomic - Gets a node for an atomic op, produces result and chain, takes /// 3 operands - SDOperand getAtomic(unsigned Opcode, SDOperand Chain, SDOperand Ptr, - SDOperand Cmp, SDOperand Swp, const Value* PtrVal, + SDValue getAtomic(unsigned Opcode, SDValue Chain, SDValue Ptr, + SDValue Cmp, SDValue Swp, const Value* PtrVal, unsigned Alignment=0); /// getAtomic - Gets a node for an atomic op, produces result and chain, takes /// 2 operands - SDOperand getAtomic(unsigned Opcode, SDOperand Chain, SDOperand Ptr, - SDOperand Val, const Value* PtrVal, + SDValue getAtomic(unsigned Opcode, SDValue Chain, SDValue Ptr, + SDValue Val, const Value* PtrVal, unsigned Alignment = 0); /// getMergeValues - Create a MERGE_VALUES node from the given operands. /// Allowed to return something different (and simpler) if Simplify is true. - SDOperand getMergeValues(const SDOperand *Ops, unsigned NumOps, + SDValue getMergeValues(const SDValue *Ops, unsigned NumOps, bool Simplify = true); /// getMergeValues - Create a MERGE_VALUES node from the given types and ops. /// Allowed to return something different (and simpler) if Simplify is true. /// May be faster than the above version if VTs is known and NumOps is large. - SDOperand getMergeValues(SDVTList VTs, const SDOperand *Ops, unsigned NumOps, + SDValue getMergeValues(SDVTList VTs, const SDValue *Ops, unsigned NumOps, bool Simplify = true) { if (Simplify && NumOps == 1) return Ops[0]; @@ -417,38 +417,38 @@ public: /// getLoad - Loads are not normal binary operators: their result type is not /// determined by their operands, and they produce a value AND a token chain. /// - SDOperand getLoad(MVT VT, SDOperand Chain, SDOperand Ptr, + SDValue getLoad(MVT VT, SDValue Chain, SDValue Ptr, const Value *SV, int SVOffset, bool isVolatile=false, unsigned Alignment=0); - SDOperand getExtLoad(ISD::LoadExtType ExtType, MVT VT, - SDOperand Chain, SDOperand Ptr, const Value *SV, + SDValue getExtLoad(ISD::LoadExtType ExtType, MVT VT, + SDValue Chain, SDValue Ptr, const Value *SV, int SVOffset, MVT EVT, bool isVolatile=false, unsigned Alignment=0); - SDOperand getIndexedLoad(SDOperand OrigLoad, SDOperand Base, - SDOperand Offset, ISD::MemIndexedMode AM); - SDOperand getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, - MVT VT, SDOperand Chain, - SDOperand Ptr, SDOperand Offset, + SDValue getIndexedLoad(SDValue OrigLoad, SDValue Base, + SDValue Offset, ISD::MemIndexedMode AM); + SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, + MVT VT, SDValue Chain, + SDValue Ptr, SDValue Offset, const Value *SV, int SVOffset, MVT EVT, bool isVolatile=false, unsigned Alignment=0); /// getStore - Helper function to build ISD::STORE nodes. /// - SDOperand getStore(SDOperand Chain, SDOperand Val, SDOperand Ptr, + SDValue getStore(SDValue Chain, SDValue Val, SDValue Ptr, const Value *SV, int SVOffset, bool isVolatile=false, unsigned Alignment=0); - SDOperand getTruncStore(SDOperand Chain, SDOperand Val, SDOperand Ptr, + SDValue getTruncStore(SDValue Chain, SDValue Val, SDValue Ptr, const Value *SV, int SVOffset, MVT TVT, bool isVolatile=false, unsigned Alignment=0); - SDOperand getIndexedStore(SDOperand OrigStoe, SDOperand Base, - SDOperand Offset, ISD::MemIndexedMode AM); + SDValue getIndexedStore(SDValue OrigStoe, SDValue Base, + SDValue Offset, ISD::MemIndexedMode AM); // getSrcValue - Construct a node to track a Value* through the backend. - SDOperand getSrcValue(const Value *v); + SDValue getSrcValue(const Value *v); // getMemOperand - Construct a node to track a memory reference // through the backend. - SDOperand getMemOperand(const MachineMemOperand &MO); + SDValue getMemOperand(const MachineMemOperand &MO); /// UpdateNodeOperands - *Mutate* the specified node in-place to have the /// specified operands. If the resultant node already exists in the DAG, @@ -456,66 +456,66 @@ public: /// already exists. If the resultant node does not exist in the DAG, the /// input node is returned. As a degenerate case, if you specify the same /// input operands as the node already has, the input node is returned. - SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op); - SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2); - SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2, - SDOperand Op3); - SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2, - SDOperand Op3, SDOperand Op4); - SDOperand UpdateNodeOperands(SDOperand N, SDOperand Op1, SDOperand Op2, - SDOperand Op3, SDOperand Op4, SDOperand Op5); - SDOperand UpdateNodeOperands(SDOperand N, - const SDOperand *Ops, unsigned NumOps); + SDValue UpdateNodeOperands(SDValue N, SDValue Op); + SDValue UpdateNodeOperands(SDValue N, SDValue Op1, SDValue Op2); + SDValue UpdateNodeOperands(SDValue N, SDValue Op1, SDValue Op2, + SDValue Op3); + SDValue UpdateNodeOperands(SDValue N, SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4); + SDValue UpdateNodeOperands(SDValue N, SDValue Op1, SDValue Op2, + SDValue Op3, SDValue Op4, SDValue Op5); + SDValue UpdateNodeOperands(SDValue N, + const SDValue *Ops, unsigned NumOps); /// SelectNodeTo - These are used for target selectors to *mutate* the /// specified node to have the specified return type, Target opcode, and /// operands. Note that target opcodes are stored as /// ~TargetOpcode in the node opcode field. The resultant node is returned. SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT); - SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT, SDOperand Op1); + SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT, SDValue Op1); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT, - SDOperand Op1, SDOperand Op2); + SDValue Op1, SDValue Op2); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT, - SDOperand Op1, SDOperand Op2, SDOperand Op3); + SDValue Op1, SDValue Op2, SDValue Op3); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, MVT VT2); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, - MVT VT2, const SDOperand *Ops, unsigned NumOps); + MVT VT2, const SDValue *Ops, unsigned NumOps); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, - MVT VT2, MVT VT3, const SDOperand *Ops, unsigned NumOps); + MVT VT2, MVT VT3, const SDValue *Ops, unsigned NumOps); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, - MVT VT2, SDOperand Op1); + MVT VT2, SDValue Op1); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2); + MVT VT2, SDValue Op1, SDValue Op2); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2, SDOperand Op3); + MVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, SDVTList VTs, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); /// MorphNodeTo - These *mutate* the specified node to have the specified /// return type, opcode, and operands. SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT); - SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT, SDOperand Op1); + SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT, SDValue Op1); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT, - SDOperand Op1, SDOperand Op2); + SDValue Op1, SDValue Op2); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT, - SDOperand Op1, SDOperand Op2, SDOperand Op3); + SDValue Op1, SDValue Op2, SDValue Op3); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, MVT VT2); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, - MVT VT2, const SDOperand *Ops, unsigned NumOps); + MVT VT2, const SDValue *Ops, unsigned NumOps); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, - MVT VT2, MVT VT3, const SDOperand *Ops, unsigned NumOps); + MVT VT2, MVT VT3, const SDValue *Ops, unsigned NumOps); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, - MVT VT2, SDOperand Op1); + MVT VT2, SDValue Op1); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2); + MVT VT2, SDValue Op1, SDValue Op2); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2, SDOperand Op3); + MVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); SDNode *MorphNodeTo(SDNode *N, unsigned Opc, SDVTList VTs, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); /// getTargetNode - These are used for target selectors to create a new node /// with specified return type(s), target opcode, and operands. @@ -524,35 +524,35 @@ public: /// node of the specified opcode and operands, it returns that node instead of /// the current one. SDNode *getTargetNode(unsigned Opcode, MVT VT); - SDNode *getTargetNode(unsigned Opcode, MVT VT, SDOperand Op1); - SDNode *getTargetNode(unsigned Opcode, MVT VT, SDOperand Op1, SDOperand Op2); + SDNode *getTargetNode(unsigned Opcode, MVT VT, SDValue Op1); + SDNode *getTargetNode(unsigned Opcode, MVT VT, SDValue Op1, SDValue Op2); SDNode *getTargetNode(unsigned Opcode, MVT VT, - SDOperand Op1, SDOperand Op2, SDOperand Op3); + SDValue Op1, SDValue Op2, SDValue Op3); SDNode *getTargetNode(unsigned Opcode, MVT VT, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2); - SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, SDOperand Op1); + SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, SDValue Op1); SDNode *getTargetNode(unsigned Opcode, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2); + MVT VT2, SDValue Op1, SDValue Op2); SDNode *getTargetNode(unsigned Opcode, MVT VT1, - MVT VT2, SDOperand Op1, SDOperand Op2, SDOperand Op3); + MVT VT2, SDValue Op1, SDValue Op2, SDValue Op3); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3, - SDOperand Op1, SDOperand Op2); + SDValue Op1, SDValue Op2); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3, - SDOperand Op1, SDOperand Op2, SDOperand Op3); + SDValue Op1, SDValue Op2, SDValue Op3); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3, MVT VT4, - const SDOperand *Ops, unsigned NumOps); + const SDValue *Ops, unsigned NumOps); SDNode *getTargetNode(unsigned Opcode, const std::vector<MVT> &ResultTys, - const SDOperand *Ops, unsigned NumOps); + const SDValue *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); + const SDValue *Ops, unsigned NumOps); /// DAGUpdateListener - Clients of various APIs that cause global effects on /// the DAG can optionally implement this interface. This allows the clients @@ -588,22 +588,22 @@ public: /// informed about nodes that are deleted and modified due to recursive /// changes in the dag. /// - void ReplaceAllUsesWith(SDOperand From, SDOperand Op, + void ReplaceAllUsesWith(SDValue From, SDValue Op, DAGUpdateListener *UpdateListener = 0); void ReplaceAllUsesWith(SDNode *From, SDNode *To, DAGUpdateListener *UpdateListener = 0); - void ReplaceAllUsesWith(SDNode *From, const SDOperand *To, + void ReplaceAllUsesWith(SDNode *From, const SDValue *To, DAGUpdateListener *UpdateListener = 0); /// ReplaceAllUsesOfValueWith - Replace any uses of From with To, leaving /// uses of other values produced by From.Val alone. - void ReplaceAllUsesOfValueWith(SDOperand From, SDOperand To, + void ReplaceAllUsesOfValueWith(SDValue From, SDValue To, DAGUpdateListener *UpdateListener = 0); /// ReplaceAllUsesOfValuesWith - Like ReplaceAllUsesOfValueWith, but /// for multiple values at once. This correctly handles the case where /// there is an overlap between the From values and the To values. - void ReplaceAllUsesOfValuesWith(const SDOperand *From, const SDOperand *To, + void ReplaceAllUsesOfValuesWith(const SDValue *From, const SDValue *To, unsigned Num, DAGUpdateListener *UpdateListener = 0); @@ -640,20 +640,20 @@ public: /// CreateStackTemporary - Create a stack temporary, suitable for holding the /// specified value type. If minAlign is specified, the slot size will have /// at least that alignment. - SDOperand CreateStackTemporary(MVT VT, unsigned minAlign = 1); + SDValue CreateStackTemporary(MVT VT, unsigned minAlign = 1); /// FoldSetCC - Constant fold a setcc to true or false. - SDOperand FoldSetCC(MVT VT, SDOperand N1, - SDOperand N2, ISD::CondCode Cond); + SDValue FoldSetCC(MVT VT, SDValue N1, + SDValue N2, ISD::CondCode Cond); /// SignBitIsZero - Return true if the sign bit of Op is known to be zero. We /// use this predicate to simplify operations downstream. - bool SignBitIsZero(SDOperand Op, unsigned Depth = 0) const; + bool SignBitIsZero(SDValue Op, unsigned Depth = 0) const; /// MaskedValueIsZero - Return true if 'Op & Mask' is known to be zero. We /// use this predicate to simplify operations downstream. Op and Mask are /// known to be the same type. - bool MaskedValueIsZero(SDOperand Op, const APInt &Mask, unsigned Depth = 0) + bool MaskedValueIsZero(SDValue Op, const APInt &Mask, unsigned Depth = 0) const; /// ComputeMaskedBits - Determine which of the bits specified in Mask are @@ -661,7 +661,7 @@ public: /// bitsets. This code only analyzes bits in Mask, in order to short-circuit /// processing. Targets can implement the computeMaskedBitsForTargetNode /// method in the TargetLowering class to allow target nodes to be understood. - void ComputeMaskedBits(SDOperand Op, const APInt &Mask, APInt &KnownZero, + void ComputeMaskedBits(SDValue Op, const APInt &Mask, APInt &KnownZero, APInt &KnownOne, unsigned Depth = 0) const; /// ComputeNumSignBits - Return the number of times the sign bit of the @@ -671,24 +671,24 @@ public: /// the top 3 bits are all equal to each other, so we return 3. Targets can /// implement the ComputeNumSignBitsForTarget method in the TargetLowering /// class to allow target nodes to be understood. - unsigned ComputeNumSignBits(SDOperand Op, unsigned Depth = 0) const; + unsigned ComputeNumSignBits(SDValue Op, unsigned Depth = 0) const; - /// isVerifiedDebugInfoDesc - Returns true if the specified SDOperand has + /// isVerifiedDebugInfoDesc - Returns true if the specified SDValue has /// been verified as a debug information descriptor. - bool isVerifiedDebugInfoDesc(SDOperand Op) const; + bool isVerifiedDebugInfoDesc(SDValue Op) const; /// getShuffleScalarElt - Returns the scalar element that will make up the ith /// element of the result of the vector shuffle. - SDOperand getShuffleScalarElt(const SDNode *N, unsigned Idx); + SDValue getShuffleScalarElt(const SDNode *N, unsigned Idx); private: inline alist_traits<SDNode, LargestSDNode>::AllocatorType &getAllocator(); void RemoveNodeFromCSEMaps(SDNode *N); SDNode *AddNonLeafNodeToCSEMaps(SDNode *N); - SDNode *FindModifiedNodeSlot(SDNode *N, SDOperand Op, void *&InsertPos); - SDNode *FindModifiedNodeSlot(SDNode *N, SDOperand Op1, SDOperand Op2, + SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos); + SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2, void *&InsertPos); - SDNode *FindModifiedNodeSlot(SDNode *N, const SDOperand *Ops, unsigned NumOps, + SDNode *FindModifiedNodeSlot(SDNode *N, const SDValue *Ops, unsigned NumOps, void *&InsertPos); void DeleteNodeNotInCSEMaps(SDNode *N); |