[llvm-commits] [llvm] r63259 - in /llvm/trunk: include/llvm/CodeGen/SelectionDAG.h lib/CodeGen/SelectionDAG/SelectionDAG.cpp
Dale Johannesen
dalej at apple.com
Wed Jan 28 17:08:26 PST 2009
On Jan 28, 2009, at 5:06 PMPST, Dan Gohman wrote:
> Hi Dale,
>
> Instead of duplicating all that code, could you make the non-DebugLoc-
> aware
> accessors just thin wrappers around the DebugLoc-aware ones, like
> this:
>
> SDValue getBasicBlock(MachineBasicBlock *MBB) {
> return getBasicBLock(MBB, DebugLoc::getUnknownLoc());
> }
>
> and so on? Thanks,
>
> Dan
No, I decided not to do that on the grounds that it would encourage
people to remove references to the old versions faster.
> On Jan 28, 2009, at 4:47 PM, Dale Johannesen wrote:
>
>> Author: johannes
>> Date: Wed Jan 28 18:47:48 2009
>> New Revision: 63259
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=63259&view=rev
>> Log:
>> Add DebugLoc-sensitive versions of many node creation
>> functions. Currently omitted: memcpy, memmove, memset.
>>
>>
>> Modified:
>> llvm/trunk/include/llvm/CodeGen/SelectionDAG.h
>> llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
>>
>> Modified: llvm/trunk/include/llvm/CodeGen/SelectionDAG.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAG.h?rev=63259&r1=63258&r2=63259&view=diff
>>
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =====================================================================
>> --- llvm/trunk/include/llvm/CodeGen/SelectionDAG.h (original)
>> +++ llvm/trunk/include/llvm/CodeGen/SelectionDAG.h Wed Jan 28
>> 18:47:48 2009
>> @@ -307,14 +307,19 @@
>> return getConstantPool(C, VT, Align, Offset, true);
>> }
>> SDValue getBasicBlock(MachineBasicBlock *MBB);
>> + SDValue getBasicBlock(MachineBasicBlock *MBB, DebugLoc dl);
>> SDValue getExternalSymbol(const char *Sym, MVT VT);
>> + SDValue getExternalSymbol(const char *Sym, DebugLoc dl, MVT VT);
>> SDValue getTargetExternalSymbol(const char *Sym, MVT VT);
>> + SDValue getTargetExternalSymbol(const char *Sym, DebugLoc dl, MVT
>> VT);
>> SDValue getArgFlags(ISD::ArgFlagsTy Flags);
>> SDValue getValueType(MVT);
>> SDValue getRegister(unsigned Reg, MVT VT);
>> SDValue getDbgStopPoint(SDValue Root, unsigned Line, unsigned Col,
>> Value *CU);
>> SDValue getLabel(unsigned Opcode, SDValue Root, unsigned LabelID);
>> + SDValue getLabel(unsigned Opcode, DebugLoc dl, SDValue Root,
>> + unsigned LabelID);
>>
>> SDValue getCopyToReg(SDValue Chain, unsigned Reg, SDValue N) {
>> return getNode(ISD::CopyToReg, MVT::Other, Chain,
>> @@ -506,12 +511,18 @@
>> SDValue getAtomic(unsigned Opcode, MVT MemVT, SDValue Chain,
>> SDValue Ptr,
>> SDValue Cmp, SDValue Swp, const Value* PtrVal,
>> unsigned Alignment=0);
>> + SDValue getAtomic(unsigned Opcode, DebugLoc dl, MVT MemVT,
>> 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 and
>> /// takes 2 operands.
>> SDValue getAtomic(unsigned Opcode, MVT MemVT, SDValue Chain,
>> SDValue Ptr,
>> SDValue Val, const Value* PtrVal,
>> unsigned Alignment = 0);
>> + SDValue getAtomic(unsigned Opcode, DebugLoc dl, MVT MemVT,
>> SDValue Chain,
>> + SDValue Ptr, SDValue Val, const Value* PtrVal,
>> + unsigned Alignment = 0);
>>
>> /// getMemIntrinsicNode - Creates a MemIntrinsicNode that may
>> produce a
>> /// result and takes a list of operands.
>> @@ -521,12 +532,23 @@
>> MVT MemVT, const Value *srcValue, int
>> SVOff,
>> unsigned Align = 0, bool Vol = false,
>> bool ReadMem = true, bool WriteMem =
>> true);
>> + SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl,
>> + const MVT *VTs, unsigned NumVTs,
>> + const SDValue *Ops, unsigned NumOps,
>> + MVT MemVT, const Value *srcValue, int
>> SVOff,
>> + unsigned Align = 0, bool Vol = false,
>> + bool ReadMem = true, bool WriteMem =
>> true);
>>
>> SDValue getMemIntrinsicNode(unsigned Opcode, SDVTList VTList,
>> const SDValue *Ops, unsigned NumOps,
>> MVT MemVT, const Value *srcValue, int
>> SVOff,
>> unsigned Align = 0, bool Vol = false,
>> bool ReadMem = true, bool WriteMem =
>> true);
>> + SDValue getMemIntrinsicNode(unsigned Opcode, DebugLoc dl,
>> SDVTList VTList,
>> + const SDValue *Ops, unsigned NumOps,
>> + MVT MemVT, const Value *srcValue, int
>> SVOff,
>> + unsigned Align = 0, bool Vol = false,
>> + bool ReadMem = true, bool WriteMem =
>> true);
>>
>> /// getMergeValues - Create a MERGE_VALUES node from the given
>> operands.
>> SDValue getMergeValues(const SDValue *Ops, unsigned NumOps);
>> @@ -536,6 +558,9 @@
>> SDValue getCall(unsigned CallingConv, bool IsVarArgs, bool
>> IsTailCall,
>> bool isInreg, SDVTList VTs, const SDValue *Operands,
>> unsigned NumOperands);
>> + SDValue getCall(unsigned CallingConv, DebugLoc dl, bool IsVarArgs,
>> + bool IsTailCall, bool isInreg, SDVTList VTs,
>> + const SDValue *Operands, unsigned NumOperands);
>>
>> /// 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.
>> @@ -543,28 +568,50 @@
>> SDValue getLoad(MVT VT, SDValue Chain, SDValue Ptr,
>> const Value *SV, int SVOffset, bool
>> isVolatile=false,
>> unsigned Alignment=0);
>> + SDValue getLoad(MVT VT, DebugLoc dl, SDValue Chain, SDValue Ptr,
>> + const Value *SV, int SVOffset, bool
>> isVolatile=false,
>> + unsigned Alignment=0);
>> SDValue getExtLoad(ISD::LoadExtType ExtType, MVT VT,
>> SDValue Chain, SDValue Ptr, const Value *SV,
>> int SVOffset, MVT EVT, bool isVolatile=false,
>> unsigned Alignment=0);
>> + SDValue getExtLoad(ISD::LoadExtType ExtType, DebugLoc dl, MVT VT,
>> + SDValue Chain, SDValue Ptr, const Value *SV,
>> + int SVOffset, MVT EVT, bool isVolatile=false,
>> + unsigned Alignment=0);
>> SDValue getIndexedLoad(SDValue OrigLoad, SDValue Base,
>> SDValue Offset, ISD::MemIndexedMode AM);
>> + SDValue getIndexedLoad(SDValue OrigLoad, DebugLoc dl, 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);
>> + SDValue getLoad(ISD::MemIndexedMode AM, DebugLoc dl,
>> 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.
>> ///
>> SDValue getStore(SDValue Chain, SDValue Val, SDValue Ptr,
>> const Value *SV, int SVOffset, bool
>> isVolatile=false,
>> unsigned Alignment=0);
>> + SDValue getStore(SDValue Chain, DebugLoc dl, SDValue Val, SDValue
>> Ptr,
>> + const Value *SV, int SVOffset, bool
>> isVolatile=false,
>> + unsigned Alignment=0);
>> SDValue getTruncStore(SDValue Chain, SDValue Val, SDValue Ptr,
>> const Value *SV, int SVOffset, MVT TVT,
>> bool isVolatile=false, unsigned
>> Alignment=0);
>> + SDValue getTruncStore(SDValue Chain, DebugLoc dl, SDValue Val,
>> SDValue Ptr,
>> + const Value *SV, int SVOffset, MVT TVT,
>> + bool isVolatile=false, unsigned
>> Alignment=0);
>> SDValue getIndexedStore(SDValue OrigStoe, SDValue Base,
>> SDValue Offset, ISD::MemIndexedMode AM);
>> + SDValue getIndexedStore(SDValue OrigStoe, DebugLoc dl, SDValue
>> Base,
>> + SDValue Offset, ISD::MemIndexedMode AM);
>>
>> /// getSrcValue - Construct a node to track a Value* through the
>> backend.
>> SDValue getSrcValue(const Value *v);
>> @@ -652,30 +699,72 @@
>> /// 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, DebugLoc dl, MVT VT);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT, SDValue Op1);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT,
>> SDValue Op1);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT, SDValue Op1,
>> SDValue Op2);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT,
>> SDValue Op1,
>> + SDValue Op2);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT,
>> SDValue Op1, SDValue Op2, SDValue Op3);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT,
>> + SDValue Op1, SDValue Op2, SDValue Op3);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT,
>> const SDValue *Ops, unsigned NumOps);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT,
>> + const SDValue *Ops, unsigned NumOps);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, SDValue
>> Op1);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2,
>> + SDValue Op1);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, SDValue Op1, SDValue Op2);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1,
>> + MVT VT2, SDValue Op1, SDValue Op2);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, SDValue Op1, SDValue Op2, SDValue
>> Op3);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1,
>> + MVT VT2, SDValue Op1, SDValue Op2, SDValue
>> Op3);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2,
>> const SDValue *Ops, unsigned NumOps);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2,
>> + const SDValue *Ops, unsigned NumOps);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
>> SDValue Op1, SDValue Op2);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2, MVT VT3,
>> + SDValue Op1, SDValue Op2);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
>> SDValue Op1, SDValue Op2, SDValue Op3);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2, MVT VT3,
>> + SDValue Op1, SDValue Op2, SDValue Op3);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
>> const SDValue *Ops, unsigned NumOps);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2, MVT VT3,
>> + const SDValue *Ops, unsigned NumOps);
>> +
>> SDNode *getTargetNode(unsigned Opcode, MVT VT1, MVT VT2, MVT VT3,
>> MVT VT4,
>> const SDValue *Ops, unsigned NumOps);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl, MVT VT1, MVT
>> VT2, MVT VT3,
>> + MVT VT4, const SDValue *Ops, unsigned
>> NumOps);
>> +
>> SDNode *getTargetNode(unsigned Opcode, const std::vector<MVT>
>> &ResultTys,
>> const SDValue *Ops, unsigned NumOps);
>> + SDNode *getTargetNode(unsigned Opcode, DebugLoc dl,
>> + const std::vector<MVT> &ResultTys, const
>> SDValue *Ops,
>> + unsigned NumOps);
>>
>> /// getNodeIfExists - Get the specified node if it's already
>> available, or
>> /// else return NULL.
>>
>> Modified: llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp?rev=63259&r1=63258&r2=63259&view=diff
>>
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =
>> =====================================================================
>> --- llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp (original)
>> +++ llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAG.cpp Wed Jan 28
>> 18:47:48 2009
>> @@ -1068,6 +1068,20 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getBasicBlock(MachineBasicBlock *MBB,
>> DebugLoc dl) {
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::BasicBlock, getVTList(MVT::Other), 0, 0);
>> + ID.AddPointer(MBB);
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<BasicBlockSDNode>();
>> + new (N) BasicBlockSDNode(MBB, dl);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getArgFlags(ISD::ArgFlagsTy Flags) {
>> FoldingSetNodeID ID;
>> AddNodeIDNode(ID, ISD::ARG_FLAGS, getVTList(MVT::Other), 0, 0);
>> @@ -1105,6 +1119,15 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getExternalSymbol(const char *Sym, DebugLoc
>> dl, MVT VT) {
>> + SDNode *&N = ExternalSymbols[Sym];
>> + if (N) return SDValue(N, 0);
>> + N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
>> + new (N) ExternalSymbolSDNode(false, dl, Sym, VT);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, MVT
>> VT) {
>> SDNode *&N = TargetExternalSymbols[Sym];
>> if (N) return SDValue(N, 0);
>> @@ -1114,6 +1137,16 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym,
>> DebugLoc dl,
>> + MVT VT) {
>> + SDNode *&N = TargetExternalSymbols[Sym];
>> + if (N) return SDValue(N, 0);
>> + N = NodeAllocator.Allocate<ExternalSymbolSDNode>();
>> + new (N) ExternalSymbolSDNode(true, dl, Sym, VT);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getCondCode(ISD::CondCode Cond) {
>> if ((unsigned)Cond >= CondCodeNodes.size())
>> CondCodeNodes.resize(Cond+1);
>> @@ -1186,6 +1219,23 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getLabel(unsigned Opcode, DebugLoc dl,
>> + SDValue Root,
>> + unsigned LabelID) {
>> + FoldingSetNodeID ID;
>> + SDValue Ops[] = { Root };
>> + AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), &Ops[0], 1);
>> + ID.AddInteger(LabelID);
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<LabelSDNode>();
>> + new (N) LabelSDNode(Opcode, dl, Root, LabelID);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getSrcValue(const Value *V) {
>> assert((!V || isa<PointerType>(V->getType())) &&
>> "SrcValue is not a pointer?");
>> @@ -3353,6 +3403,34 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, MVT
>> MemVT,
>> + SDValue Chain,
>> + SDValue Ptr, SDValue Cmp,
>> + SDValue Swp, const Value* PtrVal,
>> + unsigned Alignment) {
>> + assert(Opcode == ISD::ATOMIC_CMP_SWAP && "Invalid Atomic Op");
>> + assert(Cmp.getValueType() == Swp.getValueType() && "Invalid
>> Atomic Op Types");
>> +
>> + MVT VT = Cmp.getValueType();
>> +
>> + if (Alignment == 0) // Ensure that codegen never sees alignment 0
>> + Alignment = getMVTAlignment(MemVT);
>> +
>> + SDVTList VTs = getVTList(VT, MVT::Other);
>> + FoldingSetNodeID ID;
>> + SDValue Ops[] = {Chain, Ptr, Cmp, Swp};
>> + AddNodeIDNode(ID, Opcode, VTs, Ops, 4);
>> + void* IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
>> + new (N) AtomicSDNode(Opcode, dl, VTs, MemVT,
>> + Chain, Ptr, Cmp, Swp, PtrVal, Alignment);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getAtomic(unsigned Opcode, MVT MemVT,
>> SDValue Chain,
>> SDValue Ptr, SDValue Val,
>> @@ -3391,6 +3469,44 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getAtomic(unsigned Opcode, DebugLoc dl, MVT
>> MemVT,
>> + SDValue Chain,
>> + SDValue Ptr, SDValue Val,
>> + const Value* PtrVal,
>> + unsigned Alignment) {
>> + assert((Opcode == ISD::ATOMIC_LOAD_ADD ||
>> + Opcode == ISD::ATOMIC_LOAD_SUB ||
>> + Opcode == ISD::ATOMIC_LOAD_AND ||
>> + Opcode == ISD::ATOMIC_LOAD_OR ||
>> + Opcode == ISD::ATOMIC_LOAD_XOR ||
>> + Opcode == ISD::ATOMIC_LOAD_NAND ||
>> + Opcode == ISD::ATOMIC_LOAD_MIN ||
>> + Opcode == ISD::ATOMIC_LOAD_MAX ||
>> + Opcode == ISD::ATOMIC_LOAD_UMIN ||
>> + Opcode == ISD::ATOMIC_LOAD_UMAX ||
>> + Opcode == ISD::ATOMIC_SWAP) &&
>> + "Invalid Atomic Op");
>> +
>> + MVT VT = Val.getValueType();
>> +
>> + if (Alignment == 0) // Ensure that codegen never sees alignment 0
>> + Alignment = getMVTAlignment(MemVT);
>> +
>> + SDVTList VTs = getVTList(VT, MVT::Other);
>> + FoldingSetNodeID ID;
>> + SDValue Ops[] = {Chain, Ptr, Val};
>> + AddNodeIDNode(ID, Opcode, VTs, Ops, 3);
>> + void* IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode* N = NodeAllocator.Allocate<AtomicSDNode>();
>> + new (N) AtomicSDNode(Opcode, dl, VTs, MemVT,
>> + Chain, Ptr, Val, PtrVal, Alignment);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> /// getMergeValues - Create a MERGE_VALUES node from the given
>> operands.
>> /// Allowed to return something different (and simpler) if Simplify
>> is true.
>> SDValue SelectionDAG::getMergeValues(const SDValue *Ops, unsigned
>> NumOps) {
>> @@ -3417,6 +3533,18 @@
>> }
>>
>> SDValue
>> +SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl,
>> + const MVT *VTs, unsigned NumVTs,
>> + const SDValue *Ops, unsigned
>> NumOps,
>> + MVT MemVT, const Value *srcValue,
>> int SVOff,
>> + unsigned Align, bool Vol,
>> + bool ReadMem, bool WriteMem) {
>> + return getMemIntrinsicNode(Opcode, dl, makeVTList(VTs, NumVTs),
>> Ops, NumOps,
>> + MemVT, srcValue, SVOff, Align, Vol,
>> + ReadMem, WriteMem);
>> +}
>> +
>> +SDValue
>> SelectionDAG::getMemIntrinsicNode(unsigned Opcode, SDVTList VTList,
>> const SDValue *Ops, unsigned NumOps,
>> MVT MemVT, const Value *srcValue,
>> int SVOff,
>> @@ -3445,6 +3573,34 @@
>> }
>>
>> SDValue
>> +SelectionDAG::getMemIntrinsicNode(unsigned Opcode, DebugLoc dl,
>> SDVTList VTList,
>> + const SDValue *Ops, unsigned
>> NumOps,
>> + MVT MemVT, const Value *srcValue,
>> int SVOff,
>> + unsigned Align, bool Vol,
>> + bool ReadMem, bool WriteMem) {
>> + // Memoize the node unless it returns a flag.
>> + MemIntrinsicSDNode *N;
>> + if (VTList.VTs[VTList.NumVTs-1] != MVT::Flag) {
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, Opcode, VTList, Ops, NumOps);
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> +
>> + N = NodeAllocator.Allocate<MemIntrinsicSDNode>();
>> + new (N) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps,
>> MemVT,
>> + srcValue, SVOff, Align, Vol,
>> ReadMem, WriteMem);
>> + CSEMap.InsertNode(N, IP);
>> + } else {
>> + N = NodeAllocator.Allocate<MemIntrinsicSDNode>();
>> + new (N) MemIntrinsicSDNode(Opcode, dl, VTList, Ops, NumOps,
>> MemVT,
>> + srcValue, SVOff, Align, Vol,
>> ReadMem, WriteMem);
>> + }
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> +SDValue
>> SelectionDAG::getCall(unsigned CallingConv, bool IsVarArgs, bool
>> IsTailCall,
>> bool IsInreg, SDVTList VTs,
>> const SDValue *Operands, unsigned NumOperands) {
>> @@ -3470,6 +3626,31 @@
>> }
>>
>> SDValue
>> +SelectionDAG::getCall(unsigned CallingConv, DebugLoc dl, bool
>> IsVarArgs,
>> + bool IsTailCall, bool IsInreg, SDVTList VTs,
>> + const SDValue *Operands, unsigned
>> NumOperands) {
>> + // Do not include isTailCall in the folding set profile.
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::CALL, VTs, Operands, NumOperands);
>> + ID.AddInteger(CallingConv);
>> + ID.AddInteger(IsVarArgs);
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP)) {
>> + // Instead of including isTailCall in the folding set, we just
>> + // set the flag of the existing node.
>> + if (!IsTailCall)
>> + cast<CallSDNode>(E)->setNotTailCall();
>> + return SDValue(E, 0);
>> + }
>> + SDNode *N = NodeAllocator.Allocate<CallSDNode>();
>> + new (N) CallSDNode(CallingConv, dl, IsVarArgs, IsTailCall,
>> IsInreg,
>> + VTs, Operands, NumOperands);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> +SDValue
>> SelectionDAG::getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType
>> ExtType,
>> MVT VT, SDValue Chain,
>> SDValue Ptr, SDValue Offset,
>> @@ -3520,6 +3701,57 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue
>> +SelectionDAG::getLoad(ISD::MemIndexedMode AM, DebugLoc dl,
>> + ISD::LoadExtType ExtType, MVT VT, SDValue
>> Chain,
>> + SDValue Ptr, SDValue Offset,
>> + const Value *SV, int SVOffset, MVT EVT,
>> + bool isVolatile, unsigned Alignment) {
>> + if (Alignment == 0) // Ensure that codegen never sees alignment 0
>> + Alignment = getMVTAlignment(VT);
>> +
>> + if (VT == EVT) {
>> + ExtType = ISD::NON_EXTLOAD;
>> + } else if (ExtType == ISD::NON_EXTLOAD) {
>> + assert(VT == EVT && "Non-extending load from different memory
>> type!");
>> + } else {
>> + // Extending load.
>> + if (VT.isVector())
>> + assert(EVT.getVectorNumElements() ==
>> VT.getVectorNumElements() &&
>> + "Invalid vector extload!");
>> + else
>> + assert(EVT.bitsLT(VT) &&
>> + "Should only be an extending load, not truncating!");
>> + assert((ExtType == ISD::EXTLOAD || VT.isInteger()) &&
>> + "Cannot sign/zero extend a FP/Vector load!");
>> + assert(VT.isInteger() == EVT.isInteger() &&
>> + "Cannot convert from FP to Int or Int -> FP!");
>> + }
>> +
>> + bool Indexed = AM != ISD::UNINDEXED;
>> + assert((Indexed || Offset.getOpcode() == ISD::UNDEF) &&
>> + "Unindexed load with an offset!");
>> +
>> + SDVTList VTs = Indexed ?
>> + getVTList(VT, Ptr.getValueType(), MVT::Other) : getVTList(VT,
>> MVT::Other);
>> + SDValue Ops[] = { Chain, Ptr, Offset };
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::LOAD, VTs, Ops, 3);
>> + ID.AddInteger(AM);
>> + ID.AddInteger(ExtType);
>> + ID.AddInteger(EVT.getRawBits());
>> + ID.AddInteger(encodeMemSDNodeFlags(isVolatile, Alignment));
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<LoadSDNode>();
>> + new (N) LoadSDNode(Ops, dl, VTs, AM, ExtType, EVT, SV, SVOffset,
>> + Alignment, isVolatile);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getLoad(MVT VT,
>> SDValue Chain, SDValue Ptr,
>> const Value *SV, int SVOffset,
>> @@ -3529,6 +3761,15 @@
>> SV, SVOffset, VT, isVolatile, Alignment);
>> }
>>
>> +SDValue SelectionDAG::getLoad(MVT VT, DebugLoc dl,
>> + SDValue Chain, SDValue Ptr,
>> + const Value *SV, int SVOffset,
>> + bool isVolatile, unsigned Alignment) {
>> + SDValue Undef = getNode(ISD::UNDEF, Ptr.getValueType());
>> + return getLoad(ISD::UNINDEXED, dl, ISD::NON_EXTLOAD, VT, Chain,
>> Ptr, Undef,
>> + SV, SVOffset, VT, isVolatile, Alignment);
>> +}
>> +
>> SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, MVT VT,
>> SDValue Chain, SDValue Ptr,
>> const Value *SV,
>> @@ -3539,6 +3780,16 @@
>> SV, SVOffset, EVT, isVolatile, Alignment);
>> }
>>
>> +SDValue SelectionDAG::getExtLoad(ISD::LoadExtType ExtType, DebugLoc
>> dl, MVT VT,
>> + SDValue Chain, SDValue Ptr,
>> + const Value *SV,
>> + int SVOffset, MVT EVT,
>> + bool isVolatile, unsigned
>> Alignment) {
>> + SDValue Undef = getNode(ISD::UNDEF, Ptr.getValueType());
>> + return getLoad(ISD::UNINDEXED, dl, ExtType, VT, Chain, Ptr, Undef,
>> + SV, SVOffset, EVT, isVolatile, Alignment);
>> +}
>> +
>> SDValue
>> SelectionDAG::getIndexedLoad(SDValue OrigLoad, SDValue Base,
>> SDValue Offset, ISD::MemIndexedMode AM) {
>> @@ -3551,6 +3802,18 @@
>> LD->isVolatile(), LD->getAlignment());
>> }
>>
>> +SDValue
>> +SelectionDAG::getIndexedLoad(SDValue OrigLoad, DebugLoc dl, SDValue
>> Base,
>> + SDValue Offset, ISD::MemIndexedMode
>> AM) {
>> + LoadSDNode *LD = cast<LoadSDNode>(OrigLoad);
>> + assert(LD->getOffset().getOpcode() == ISD::UNDEF &&
>> + "Load is already a indexed load!");
>> + return getLoad(AM, dl, LD->getExtensionType(),
>> OrigLoad.getValueType(),
>> + LD->getChain(), Base, Offset, LD->getSrcValue(),
>> + LD->getSrcValueOffset(), LD->getMemoryVT(),
>> + LD->isVolatile(), LD->getAlignment());
>> +}
>> +
>> SDValue SelectionDAG::getStore(SDValue Chain, SDValue Val,
>> SDValue Ptr, const Value *SV, int
>> SVOffset,
>> bool isVolatile, unsigned Alignment) {
>> @@ -3579,6 +3842,34 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getStore(SDValue Chain, DebugLoc dl, SDValue
>> Val,
>> + SDValue Ptr, const Value *SV, int
>> SVOffset,
>> + bool isVolatile, unsigned
>> Alignment) {
>> + MVT VT = Val.getValueType();
>> +
>> + if (Alignment == 0) // Ensure that codegen never sees alignment 0
>> + Alignment = getMVTAlignment(VT);
>> +
>> + SDVTList VTs = getVTList(MVT::Other);
>> + SDValue Undef = getNode(ISD::UNDEF, Ptr.getValueType());
>> + SDValue Ops[] = { Chain, Val, Ptr, Undef };
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
>> + ID.AddInteger(ISD::UNINDEXED);
>> + ID.AddInteger(false);
>> + ID.AddInteger(VT.getRawBits());
>> + ID.AddInteger(encodeMemSDNodeFlags(isVolatile, Alignment));
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
>> + new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, false,
>> + VT, SV, SVOffset, Alignment, isVolatile);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getTruncStore(SDValue Chain, SDValue Val,
>> SDValue Ptr, const Value *SV,
>> int SVOffset, MVT SVT,
>> @@ -3615,6 +3906,42 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue SelectionDAG::getTruncStore(SDValue Chain, DebugLoc dl,
>> SDValue Val,
>> + SDValue Ptr, const Value *SV,
>> + int SVOffset, MVT SVT,
>> + bool isVolatile, unsigned
>> Alignment) {
>> + MVT VT = Val.getValueType();
>> +
>> + if (VT == SVT)
>> + return getStore(Chain, dl, Val, Ptr, SV, SVOffset, isVolatile,
>> Alignment);
>> +
>> + assert(VT.bitsGT(SVT) && "Not a truncation?");
>> + assert(VT.isInteger() == SVT.isInteger() &&
>> + "Can't do FP-INT conversion!");
>> +
>> + if (Alignment == 0) // Ensure that codegen never sees alignment 0
>> + Alignment = getMVTAlignment(VT);
>> +
>> + SDVTList VTs = getVTList(MVT::Other);
>> + SDValue Undef = getNode(ISD::UNDEF, Ptr.getValueType());
>> + SDValue Ops[] = { Chain, Val, Ptr, Undef };
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
>> + ID.AddInteger(ISD::UNINDEXED);
>> + ID.AddInteger(1);
>> + ID.AddInteger(SVT.getRawBits());
>> + ID.AddInteger(encodeMemSDNodeFlags(isVolatile, Alignment));
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
>> + new (N) StoreSDNode(Ops, dl, VTs, ISD::UNINDEXED, true,
>> + SVT, SV, SVOffset, Alignment, isVolatile);
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue
>> SelectionDAG::getIndexedStore(SDValue OrigStore, SDValue Base,
>> SDValue Offset, ISD::MemIndexedMode
>> AM) {
>> @@ -3642,6 +3969,33 @@
>> return SDValue(N, 0);
>> }
>>
>> +SDValue
>> +SelectionDAG::getIndexedStore(SDValue OrigStore, DebugLoc dl,
>> SDValue Base,
>> + SDValue Offset, ISD::MemIndexedMode
>> AM) {
>> + StoreSDNode *ST = cast<StoreSDNode>(OrigStore);
>> + assert(ST->getOffset().getOpcode() == ISD::UNDEF &&
>> + "Store is already a indexed store!");
>> + SDVTList VTs = getVTList(Base.getValueType(), MVT::Other);
>> + SDValue Ops[] = { ST->getChain(), ST->getValue(), Base, Offset };
>> + FoldingSetNodeID ID;
>> + AddNodeIDNode(ID, ISD::STORE, VTs, Ops, 4);
>> + ID.AddInteger(AM);
>> + ID.AddInteger(ST->isTruncatingStore());
>> + ID.AddInteger(ST->getMemoryVT().getRawBits());
>> + ID.AddInteger(ST->getRawFlags());
>> + void *IP = 0;
>> + if (SDNode *E = CSEMap.FindNodeOrInsertPos(ID, IP))
>> + return SDValue(E, 0);
>> + SDNode *N = NodeAllocator.Allocate<StoreSDNode>();
>> + new (N) StoreSDNode(Ops, dl, VTs, AM,
>> + ST->isTruncatingStore(), ST->getMemoryVT(),
>> + ST->getSrcValue(), ST->getSrcValueOffset(),
>> + ST->getAlignment(), ST->isVolatile());
>> + CSEMap.InsertNode(N, IP);
>> + AllNodes.push_back(N);
>> + return SDValue(N, 0);
>> +}
>> +
>> SDValue SelectionDAG::getVAArg(MVT VT,
>> SDValue Chain, SDValue Ptr,
>> SDValue SV) {
>> @@ -4395,32 +4749,70 @@
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT) {
>> return getNode(~Opcode, VT).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT) {
>> + return getNode(~Opcode, dl, VT).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT, SDValue
>> Op1) {
>> return getNode(~Opcode, VT, Op1).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT,
>> + SDValue Op1) {
>> + return getNode(~Opcode, dl, VT, Op1).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
>> SDValue Op1, SDValue Op2) {
>> return getNode(~Opcode, VT, Op1, Op2).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT,
>> + SDValue Op1, SDValue Op2) {
>> + return getNode(~Opcode, dl, VT, Op1, Op2).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
>> SDValue Op1, SDValue Op2,
>> SDValue Op3) {
>> return getNode(~Opcode, VT, Op1, Op2, Op3).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT,
>> + SDValue Op1, SDValue Op2,
>> + SDValue Op3) {
>> + return getNode(~Opcode, dl, VT, Op1, Op2, Op3).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT,
>> const SDValue *Ops, unsigned
>> NumOps) {
>> return getNode(~Opcode, VT, Ops, NumOps).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT,
>> + const SDValue *Ops, unsigned
>> NumOps) {
>> + return getNode(~Opcode, dl, VT, Ops, NumOps).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT
>> VT2) {
>> const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> SDValue Op;
>> return getNode(~Opcode, VTs, 2, &Op, 0).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + MVT VT1, MVT VT2) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> + SDValue Op;
>> + return getNode(~Opcode, dl, VTs, 2, &Op, 0).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, SDValue Op1) {
>> const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> return getNode(~Opcode, VTs, 2, &Op1, 1).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT1,
>> + MVT VT2, SDValue Op1) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> + return getNode(~Opcode, dl, VTs, 2, &Op1, 1).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, SDValue Op1,
>> SDValue Op2) {
>> @@ -4428,6 +4820,14 @@
>> SDValue Ops[] = { Op1, Op2 };
>> return getNode(~Opcode, VTs, 2, Ops, 2).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT1,
>> + MVT VT2, SDValue Op1,
>> + SDValue Op2) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> + SDValue Ops[] = { Op1, Op2 };
>> + return getNode(~Opcode, dl, VTs, 2, Ops, 2).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, SDValue Op1,
>> SDValue Op2, SDValue Op3) {
>> @@ -4435,17 +4835,40 @@
>> SDValue Ops[] = { Op1, Op2, Op3 };
>> return getNode(~Opcode, VTs, 2, Ops, 3).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT1,
>> + MVT VT2, SDValue Op1,
>> + SDValue Op2, SDValue Op3) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> + SDValue Ops[] = { Op1, Op2, Op3 };
>> + return getNode(~Opcode, dl, VTs, 2, Ops, 3).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT
>> VT2,
>> const SDValue *Ops, unsigned
>> NumOps) {
>> const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> return getNode(~Opcode, VTs, 2, Ops, NumOps).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + MVT VT1, MVT VT2,
>> + const SDValue *Ops, unsigned
>> NumOps) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2);
>> + return getNode(~Opcode, dl, VTs, 2, Ops, NumOps).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT
>> VT2, MVT VT3,
>> SDValue Op1, SDValue Op2) {
>> const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
>> SDValue Ops[] = { Op1, Op2 };
>> return getNode(~Opcode, VTs, 3, Ops, 2).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + MVT VT1, MVT VT2, MVT VT3,
>> + SDValue Op1, SDValue Op2) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
>> + SDValue Ops[] = { Op1, Op2 };
>> + return getNode(~Opcode, dl, VTs, 3, Ops, 2).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT
>> VT2, MVT VT3,
>> SDValue Op1, SDValue Op2,
>> SDValue Op3) {
>> @@ -4453,11 +4876,27 @@
>> SDValue Ops[] = { Op1, Op2, Op3 };
>> return getNode(~Opcode, VTs, 3, Ops, 3).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + MVT VT1, MVT VT2, MVT VT3,
>> + SDValue Op1, SDValue Op2,
>> + SDValue Op3) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
>> + SDValue Ops[] = { Op1, Op2, Op3 };
>> + return getNode(~Opcode, dl, VTs, 3, Ops, 3).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1, MVT
>> VT2, MVT VT3,
>> const SDValue *Ops, unsigned
>> NumOps) {
>> const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
>> return getNode(~Opcode, VTs, 3, Ops, NumOps).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + MVT VT1, MVT VT2, MVT VT3,
>> + const SDValue *Ops, unsigned
>> NumOps) {
>> + const MVT *VTs = getNodeValueTypes(VT1, VT2, VT3);
>> + return getNode(~Opcode, VTs, 3, Ops, NumOps).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT VT1,
>> MVT VT2, MVT VT3, MVT VT4,
>> const SDValue *Ops, unsigned
>> NumOps) {
>> @@ -4469,6 +4908,18 @@
>> const MVT *VTs = getNodeValueTypes(VTList);
>> return getNode(~Opcode, VTs, 4, Ops, NumOps).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> MVT VT1,
>> + MVT VT2, MVT VT3, MVT VT4,
>> + const SDValue *Ops, unsigned
>> NumOps) {
>> + std::vector<MVT> VTList;
>> + VTList.push_back(VT1);
>> + VTList.push_back(VT2);
>> + VTList.push_back(VT3);
>> + VTList.push_back(VT4);
>> + const MVT *VTs = getNodeValueTypes(VTList);
>> + return getNode(~Opcode, dl, VTs, 4, Ops, NumOps).getNode();
>> +}
>> +
>> SDNode *SelectionDAG::getTargetNode(unsigned Opcode,
>> const std::vector<MVT> &ResultTys,
>> const SDValue *Ops, unsigned
>> NumOps) {
>> @@ -4476,6 +4927,13 @@
>> return getNode(~Opcode, VTs, ResultTys.size(),
>> Ops, NumOps).getNode();
>> }
>> +SDNode *SelectionDAG::getTargetNode(unsigned Opcode, DebugLoc dl,
>> + const std::vector<MVT>
>> &ResultTys,
>> + const SDValue *Ops, unsigned
>> NumOps) {
>> + const MVT *VTs = getNodeValueTypes(ResultTys);
>> + return getNode(~Opcode, dl, VTs, ResultTys.size(),
>> + Ops, NumOps).getNode();
>> +}
>>
>> /// getNodeIfExists - Get the specified node if it's already
>> available, or
>> /// else return NULL.
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list