Lines Matching full:getnode
101 return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
106 SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
153 return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
1770 return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1894 ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
1896 ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
1898 ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
1900 ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
1926 ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1937 ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1938 ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1943 ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1980 if (Flag.getNode())
1983 return DAG.getNode(X86ISD::RET_FLAG, dl, MVT::Other, RetOps);
2079 Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2309 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2312 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2315 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2320 ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2322 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2352 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2444 SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2478 MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2483 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
2522 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2545 return SDValue(OutRetAddr.getNode(), 1);
2696 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2699 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2704 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2705 Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2708 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2711 Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2742 if (!StackPtr.getNode())
2751 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
2758 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
2834 if (!StackPtr.getNode())
2838 Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2853 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains2);
2923 Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
2980 if (InFlag.getNode())
2990 return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, Ops);
2993 Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, Ops);
3355 return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3359 return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3396 return DAG.getNode(Opc, dl, VT, V1);
3410 return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3422 return DAG.getNode(Opc, dl, VT, V1, V2,
3440 return DAG.getNode(Opc, dl, VT, V1, V2);
3577 if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3578 !ISD::isNON_EXTLoad(RHS.getNode())) {
4047 SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
4528 if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4533 cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4547 if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4551 cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4682 if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4686 cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4697 if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4701 cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4800 N = N->getOperand(0).getNode();
4816 switch (N->getOperand(i).getNode()->getOpcode()) {
4872 if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
4879 if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
4901 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4904 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
4910 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
4916 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops);
4922 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i32, Ops);
4927 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
4931 return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4947 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops);
4949 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4953 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4957 return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
5033 V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
5044 V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
5050 return DAG.getNode(ISD::BITCAST, dl, VT, V);
5086 V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
5213 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
5232 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5268 if (!Elt.getNode())
5425 LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
5429 ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
5430 ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
5433 ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
5437 if (ThisElt.getNode())
5438 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
5443 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
5469 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
5545 return DAG.getNode(X86ISD::INSERTPS, dl, VT, V, V, InsertpsMask);
5559 SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
5560 return DAG.getNode(ISD::BITCAST, dl, VT,
5561 DAG.getNode(Opc, dl, ShVT, SrcOp,
5619 Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
5664 if (!Elt.getNode() ||
5665 (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
5668 if (Elt.getNode()->getOpcode() == ISD::UNDEF)
5670 LDBase = cast<LoadSDNode>(Elt.getNode());
5705 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5707 SDValue(NewLd.getNode(), 1));
5709 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5710 SDValue(NewLd.getNode(), 1));
5730 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5731 SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
5733 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5734 SDValue(ResNode.getNode(), 1));
5737 return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
5769 auto *BVOp = cast<BuildVectorSDNode>(Op.getNode());
5784 if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
5807 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
5854 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5858 bool IsLoad = ISD::isNormalLoad(Ld.getNode());
5864 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5871 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5877 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5961 if (!VecIn1.getNode())
5964 if (!VecIn2.getNode())
5977 if (!VecIn1.getNode())
5980 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
5984 NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
6000 if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6003 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6006 if (ISD::isBuildVectorAllOnes(Op.getNode())) {
6009 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
6037 SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
6039 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
6048 DstVec = DAG.getNode(ISD::BITCAST, dl, VT, VecAsImm);
6052 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, DstVec,
6061 Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6065 Select = DAG.getNode(ISD::SELECT, dl, SelectVT, Op.getOperand(0),
6068 return DAG.getNode(ISD::BITCAST, dl, VT, Select);
6214 LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V0_HI);
6216 HI = DAG.getNode(X86Opcode, DL, NewVT, V1_LO, V1_HI);
6221 LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V1_LO);
6225 HI = DAG.getNode(X86Opcode, DL, NewVT, V0_HI, V1_HI);
6228 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LO, HI);
6329 SDValue Sub = DAG.getNode(ExpectedOpcode, DL, VT, InVec0, InVec1);
6330 SDValue Add = DAG.getNode(NextExpectedOpcode, DL, VT, InVec0, InVec1);
6345 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, DL, MaskVT, Ops);
6364 if (Value.getNode())
6390 return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6393 return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6397 return DAG.getNode(X86ISD::HADD, DL, VT, InVec0, InVec1);
6400 return DAG.getNode(X86ISD::HSUB, DL, VT, InVec0, InVec1);
6416 return DAG.getNode(X86ISD::FHADD, DL, VT, InVec0, InVec1);
6424 return DAG.getNode(X86ISD::FHSUB, DL, VT, InVec0, InVec1);
6452 return DAG.getNode(X86Opcode, DL, VT, InVec0, InVec1);
6511 if (ISD::isBuildVectorAllZeros(Op.getNode())) {
6523 if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
6532 if (Broadcast.getNode())
6582 Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
6583 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
6596 return DAG.getNode(ISD::BITCAST, dl, VT, Item);
6606 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6612 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
6616 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6622 Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
6623 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
6631 return DAG.getNode(ISD::BITCAST, dl, VT, Item);
6641 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
6655 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
6675 if (Op.getNode()->isOnlyUserOf(Item.getNode()))
6696 SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
6698 SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT,
6712 SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
6723 if (V.getNode()) return V;
6729 if (V.getNode()) return V;
6736 if (V.getNode())
6748 V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
6787 if (LD.getNode())
6792 if (Sh.getNode())
6799 Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
6805 Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
6816 V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
6972 return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V1,
6979 return DAG.getNode(X86ISD::SHUFP, SDLoc(Op), MVT::v2f64, V1, V2,
7004 V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V1);
7008 return DAG.getNode(
7010 DAG.getNode(X86ISD::PSHUFD, SDLoc(Op), MVT::v4i32, V1,
7018 V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V1);
7019 V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, V2);
7020 return DAG.getNode(ISD::BITCAST, DL, MVT::v2i64,
7049 return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V1, V1,
7072 V2 = DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V2, V1,
7103 V1 = DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, V1, V2,
7115 return DAG.getNode(X86ISD::SHUFP, DL, MVT::v4f32, LowV, HighV,
7137 return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
7145 return DAG.getNode(ISD::BITCAST, DL, MVT::v4i32,
7148 DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V1),
7149 DAG.getNode(ISD::BITCAST, DL, MVT::v4f32, V2), Mask));
7215 V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
7216 DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
7217 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
7398 V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
7401 V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
7404 V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
7405 DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
7406 DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V),
7420 V = DAG.getNode(X86ISD::PSHUFLW, DL, MVT::v8i16, V,
7428 V = DAG.getNode(X86ISD::PSHUFHW, DL, MVT::v8i16, V,
7580 MVT::v8i16, DL, DAG.getNode(MergeFromLo ? X86ISD::UNPCKL : X86ISD::UNPCKH,
7647 return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v8i16, Evens, Odds);
7660 LoV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, LoV);
7661 HiV = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, HiV);
7663 return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
7664 DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, LoV, HiV));
7757 V1 = DAG.getNode(
7760 DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
7764 V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
7773 return DAG.getNode(
7776 DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V1),
7803 return DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, Evens, Odds);
7839 V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
7840 V1 = DAG.getNode(ISD::AND, DL, MVT::v8i16, V1,
7856 V1 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
7857 DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
7858 V2 = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16,
7859 DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
7873 return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
7966 V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, V1);
7967 V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, V2);
7968 return DAG.getNode(ISD::BITCAST, dl, VT,
8081 V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
8082 V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
8085 SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
8087 return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
8137 V1 = DAG.getNode(ISD::BITCAST, dl, ShufVT, V1);
8138 return DAG.getNode(X86ISD::PSHUFB, dl, ShufVT, V1,
8139 DAG.getNode(ISD::BUILD_VECTOR, dl, ShufVT, PshufbMask));
8226 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
8227 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
8228 NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
8269 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
8295 return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
8301 V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
8302 return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
8323 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
8347 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
8372 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
8374 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
8376 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
8439 V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
8440 DAG.getNode(ISD::BUILD_VECTOR, dl,
8446 ISD::isBuildVectorAllZeros(V2.getNode()))
8457 V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
8458 DAG.getNode(ISD::BUILD_VECTOR, dl,
8460 return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
8466 V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
8467 V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
8488 InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
8490 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
8499 InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
8502 InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
8506 InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
8514 SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
8517 InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
8521 InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
8523 InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
8526 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
8529 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
8544 bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
8545 bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
8603 SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
8604 SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
8615 if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
8627 return DAG.getNode(ISD::BITCAST, dl, VT,
8628 DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
8629 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
8637 return DAG.getNode(ISD::BITCAST, dl, VT,
8638 DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
8639 DAG.getNode(ISD::BITCAST, dl,
8649 if (NewOp.getNode())
8727 SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
8733 Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, SVOps);
8753 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
8917 V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
8918 return DAG.getNode(ISD::BITCAST, dl, VT,
8936 return DAG.getNode(ISD::BITCAST, dl, VT,
8938 DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
8939 DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
9021 SDValue NewAddr = DAG.getNode(
9081 if (!NewLoad.getNode())
9087 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, NewLoad);
9089 return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, LoadScalarToVector,
9095 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, To, NewLoad,
9102 return DAG.getNode(X86ISD::INSERTPS, dl, VT, To, From, InsertpsMask);
9172 (!ISD::isNormalLoad(V.getNode()) || !V.hasOneUse())) {
9182 V = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVecVT, V,
9185 V1 = DAG.getNode(ISD::BITCAST, DL, V1VT, V);
9189 return DAG.getNode(ISD::BITCAST, DL, VT,
9190 DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
9208 if (Broadcast.getNode())
9214 if (NewOp.getNode())
9222 if (NewOp.getNode())
9223 return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
9226 if (ISD::isBuildVectorAllZeros(V2.getNode())) {
9228 if (NewOp.getNode()) {
9235 } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
9237 if (NewOp.getNode()) {
9301 if (NewOp.getNode())
9364 if (ISD::isBuildVectorAllZeros(V1.getNode()))
9392 ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
9406 if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V1.getNode()))
9409 if (auto *BVOp = dyn_cast<BuildVectorSDNode>(V2.getNode()))
9545 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MaskVectorVT, permclMask);
9548 return DAG.getNode(X86ISD::VPERMV, dl, VT,
9549 DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
9550 return DAG.getNode(X86ISD::VPERMV3, dl, VT, V1,
9551 DAG.getNode(ISD::BITCAST, dl, VT, Mask), V2);
9563 if (NewOp.getNode())
9569 if (NewOp.getNode())
9575 if (NewOp.getNode())
9581 if (NewOp.getNode())
9654 if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
9668 LHS = DAG.getNode(ISD::BITCAST, dl, VT, LHS);
9669 RHS = DAG.getNode(ISD::BITCAST, dl, VT, RHS);
9672 SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, LHS, RHS,
9674 return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
9679 if (BlendOp.getNode())
9708 SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
9710 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
9712 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
9719 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
9720 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
9721 DAG.getNode(ISD::BITCAST, dl,
9725 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
9727 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
9729 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
9740 SDNode *User = *Op.getNode()->use_begin();
9747 SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
9748 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
9751 return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
9778 SDValue Ext = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Vec);
9779 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
9781 return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
9787 Vec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, Vec,
9789 Vec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, Vec,
9791 return DAG.getNode(X86ISD::VEXTRACT, dl, MVT::i1, Vec,
9817 SDValue Mask = DAG.getNode(X86ISD::VINSERT, dl, MaskVT,
9820 SDValue Perm = DAG.getNode(X86ISD::VPERMV, dl, VecVT, Mask, Vec);
9821 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(),
9841 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
9849 if (Res.getNode())
9859 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
9860 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
9861 getNode(ISD::BITCAST, dl,
9866 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
9868 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
9870 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
9883 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
9902 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
9934 N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
9937 return DAG.getNode(Opc, dl, VT, N0, N1, N2);
9951 N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
9952 return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
9977 SDValue ExtOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ExtVecVT,
9978 DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVecVT, Vec),
9979 DAG.getNode(ISD::ZERO_EXTEND, dl, ExtEltVT, Elt), Idx);
9980 return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
9984 SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Elt);
9986 return DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
9990 EltInVec = DAG.getNode(X86ISD::VSHLI, dl, VecVT, EltInVec,
9992 EltInVec = DAG.getNode(X86ISD::VSRLI, dl, VecVT, EltInVec,
9994 return DAG.getNode(ISD::OR, dl, VecVT, Vec, EltInVec);
10023 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
10040 N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
10043 return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
10060 Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
10068 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
10070 SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
10072 return DAG.getNode(ISD::BITCAST, dl, OpVT,
10073 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
10108 SDLoc dl(Op.getNode());
10109 SDValue Vec = Op.getNode()->getOperand(0);
10110 SDValue SubVec = Op.getNode()->getOperand(1);
10111 SDValue Idx = Op.getNode()->getOperand(2);
10113 if ((Op.getNode()->getSimpleValueType(0).is256BitVector() ||
10114 Op.getNode()->getSimpleValueType(0).is512BitVector()) &&
10115 SubVec.getNode()->getSimpleValueType(0).is128BitVector() &&
10121 if (Op.getNode()->getSimpleValueType(0).is512BitVector() &&
10122 SubVec.getNode()->getSimpleValueType(0).is256BitVector() &&
10159 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10162 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10163 DAG.getNode(X86ISD::GlobalBaseReg,
10191 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10195 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10196 DAG.getNode(X86ISD::GlobalBaseReg,
10229 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10234 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10235 DAG.getNode(X86ISD::GlobalBaseReg,
10263 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
10265 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
10269 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
10270 DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
10297 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
10299 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
10303 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
10304 DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
10317 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
10347 Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
10350 Chain = DAG.getNode(CallType, dl, NodeTys, Ops);
10367 DAG.getNode(X86ISD::GlobalBaseReg,
10400 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
10415 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
10418 return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
10458 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
10462 Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
10463 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
10473 return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
10520 SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
10524 Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10525 DAG.getNode(X86ISD::GlobalBaseReg,
10534 Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args);
10595 IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
10597 SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
10605 SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
10609 return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
10629 SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
10631 SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
10637 Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
10638 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
10640 Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
10641 Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
10647 SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
10649 SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
10658 Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
10659 Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
10661 Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0);
10662 Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1);
10796 SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
10802 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
10808 SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
10809 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
10814 Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
10816 SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
10819 Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
10820 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
10824 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
10837 SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
10843 Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
10844 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
10848 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
10849 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
10850 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
10852 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
10853 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
10855 Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
10856 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
10860 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
10866 return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
10869 return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
10886 return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
10887 DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
10902 return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
10917 SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
10965 SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
10967 FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
10975 SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
10976 return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
11057 SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
11066 ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops)
11098 return DAG.getNode(X86ISD::VZEXT, dl, VT, In);
11109 OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
11110 OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
11112 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
11126 return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
11140 SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, DL, ExtVT, In, Ld);
11143 return DAG.getNode(X86ISD::VTRUNC, DL, VT, Brcst);
11150 if (Res.getNode())
11169 if (Res.getNode())
11190 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::i32, In);
11192 In = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, In);
11193 return DAG.getNode(ISD::TRUNCATE, DL, VT, In);
11200 return DAG.getNode(X86ISD::VTRUNC, DL, VT, In);
11207 In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
11218 SDValue OneV = DAG.getNode(X86ISD::VBROADCAST, DL, InVT, Ld);
11219 SDValue And = DAG.getNode(ISD::AND, DL, InVT, OneV, In);
11220 return DAG.getNode(X86ISD::TESTM, DL, VT, And, And);
11227 In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
11230 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
11234 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
11236 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
11238 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
11239 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
11247 In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
11262 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8, pshufbMask);
11263 In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
11264 In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
11269 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
11271 return DAG.getNode(ISD::BITCAST, DL, VT, In);
11274 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
11277 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
11280 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
11281 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
11291 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
11292 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
11297 return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
11314 DAG.getNode(ISD::BITCAST, DL, NVT, In),
11316 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
11328 if (!FIST.getNode()) return Op;
11330 if (StackSlot.getNode())
11345 assert(FIST.getNode() && "Unexpected failure");
11347 if (StackSlot.getNode())
11365 return DAG.getNode(X86ISD::VFPEXT, DL, VT,
11366 DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
11396 return DAG.getNode(ISD::BITCAST, dl, VT,
11397 DAG.getNode(ISD::AND, dl, ANDVT,
11398 DAG.getNode(ISD::BITCAST, dl, ANDVT,
11400 DAG.getNode(ISD::BITCAST, dl, ANDVT, Mask)));
11402 return DAG.getNode(X86ISD::FAND, dl, VT, Op.getOperand(0), Mask);
11431 return DAG.getNode(ISD::BITCAST, dl, VT,
11432 DAG.getNode(ISD::XOR, dl, XORVT,
11433 DAG.getNode(ISD::BITCAST, dl, XORVT,
11435 DAG.getNode(ISD::BITCAST, dl, XORVT, Mask)));
11438 return DAG.getNode(X86ISD::FXOR, dl, VT, Op.getOperand(0), Mask);
11452 Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
11457 Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
11482 SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
11487 SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, SignBit);
11488 SignBit = DAG.getNode(X86ISD::FSRL, dl, MVT::v2f64, SignBit,
11490 SignBit = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, SignBit);
11491 SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, SignBit,
11515 SDValue Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Mask2);
11518 return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
11527 SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
11529 return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
11544 SDNode *N = Op.getNode();
11610 VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
11618 VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
11621 return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
11650 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
11675 cast<BinaryWithFlagsSDNode>(Op.getNode());
11692 // return DAG.getNode(X86ISD::CMP, dl, MVT::i1, Op,
11694 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
11737 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
11738 UE = Op.getNode()->use_end(); UI != UE; ++UI)
11745 dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
11782 SDValue New = DAG.getNode(ISD::AND, dl, VT, Op->getOperand(0),
11800 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
11801 UE = Op.getNode()->use_end(); UI != UE; ++UI)
11814 if (EFLAGS.getNode())
11831 return SDValue(Op.getNode(), 1);
11859 SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
11860 SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
11861 Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
11868 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
11876 SDValue New = DAG.getNode(Opcode, dl, VTs, Ops);
11878 return SDValue(New.getNode(), 1);
11905 Op0 = DAG.getNode(ExtendOp, dl, MVT::i32, Op0);
11906 Op1 = DAG.getNode(ExtendOp, dl, MVT::i32, Op1);
11910 SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
11912 return SDValue(Sub.getNode(), 1);
11914 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
11933 SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
11934 SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
11935 SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
11937 SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
11938 return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
11993 if (LHS.getNode()) {
12001 LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
12006 RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
12008 SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
12010 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
12087 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
12088 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
12089 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
12126 return DAG.getNode(Opc, dl, VT, Op0, Op1);
12128 return DAG.getNode(Opc, dl, VT, Op0, Op1,
12137 BuildVectorSDNode *BV = dyn_cast<BuildVectorSDNode>(Op1.getNode());
12159 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, ULTOp1);
12195 SDValue Cmp0 = DAG.getNode(Opc, dl, VT, Op0, Op1,
12197 SDValue Cmp1 = DAG.getNode(Opc, dl, VT, Op0, Op1,
12199 return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
12202 return DAG.getNode(Opc, dl, VT, Op0, Op1,
12224 return DAG.getNode(ISD::TRUNCATE, dl, VT,
12225 DAG.getNode(ISD::SETCC, dl, OpVT, Op0, Op1, CC));
12285 if (ULEOp1.getNode()) {
12312 Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
12313 Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
12324 SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
12327 Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
12328 Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
12331 SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
12332 SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
12341 SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
12342 Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
12347 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
12356 Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
12357 Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
12360 SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
12365 Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
12370 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
12379 Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
12380 Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
12383 SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
12390 Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
12393 Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
12421 if (NewSetCC.getNode())
12442 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
12446 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
12465 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
12468 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, SetCC);
12474 unsigned Opc = Op.getNode()->getOpcode();
12530 SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CondOp0, CondOp1,
12532 return DAG.getNode(X86ISD::SELECT, DL, VT, Cmp, Op1, Op2);
12534 SDValue Cmp = DAG.getNode(X86ISD::FSETCC, DL, VT, CondOp0, CondOp1,
12536 SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
12537 SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
12538 return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
12544 if (NewCond.getNode())
12571 SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
12574 SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
12576 SDValue(Neg.getNode(), 1));
12580 Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
12585 DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
12593 Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
12651 SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
12671 if (NewSetCC.getNode()) {
12694 SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
12712 SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
12713 return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
12721 return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops);
12735 return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
12749 SDValue Brcst = DAG.getNode(X86ISD::VBROADCASTM, dl, ExtVT, In, Ld);
12752 return DAG.getNode(X86ISD::VTRUNC, dl, VT, Brcst);
12771 return DAG.getNode(X86ISD::VSEXT, dl, VT, In);
12800 OpLo = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpLo);
12801 OpHi = DAG.getNode(X86ISD::VSEXT, dl, HalfVT, OpHi);
12803 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
12857 if (NewCond.getNode())
12898 Cond = Cond.getNode()->getOperand(1);
12946 SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
12966 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
12980 Op.getNode()->hasOneUse()) {
12985 SDNode *User = *Op.getNode()->use_begin();
12997 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
13025 if (Op.getNode()->hasOneUse()) {
13026 SDNode *User = *Op.getNode()->use_begin();
13038 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
13042 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
13056 if (Op.getNode()->hasOneUse()) {
13057 SDNode *User = *Op.getNode()->use_begin();
13068 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
13072 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
13092 if (NewSetCC.getNode()) {
13106 return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
13126 SDNode* Node = Op.getNode();
13148 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
13150 Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
13166 EVT VT = Op.getNode()->getValueType(0);
13190 SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
13202 Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
13211 SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
13252 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13261 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13271 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
13278 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
13287 assert(Op.getNode()->getNumOperands() == 4);
13294 EVT ArgVT = Op.getNode()->getValueType(0);
13390 ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
13435 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
13438 return DAG.getNode(Opc, dl, VT, SrcOp, DAG.getConstant(ShiftAmt, MVT::i8));
13467 ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, ShOps);
13474 ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
13475 return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
13578 SDValue Cond = DAG.getNode(Opc, dl, MVT::i32, LHS, RHS);
13579 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
13581 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
13587 return DAG.getNode(X86ISD::PMULUDQ, dl, Op.getValueType(),
13592 return DAG.getNode(X86ISD::PMULDQ, dl, Op.getValueType(),
13597 return DAG.getNode(ISD::MULHU, dl, Op.getValueType(),
13602 return DAG.getNode
13610 return DAG.getNode(X86ISD::SUBUS, dl, Op.getValueType(),
13658 return DAG.getNode(Opcode, dl, Op.getValueType(),
13723 return DAG.getNode(Opcode, dl, Op.getValueType(),
13752 return DAG.getNode(Opcode, dl, Op.getValueType(),
13787 return DAG.getNode(Opcode, dl, Op.getValueType(),
13795 return DAG.getNode(X86ISD::PACKSS, dl, Op.getValueType(),
13802 return DAG.getNode(X86ISD::PACKUS, dl, Op.getValueType(),
13807 return DAG.getNode(X86ISD::PSHUFB, dl, Op.getValueType(),
13811 return DAG.getNode(X86ISD::PSHUFD, dl, Op.getValueType(),
13815 return DAG.getNode(X86ISD::PSHUFLW, dl, Op.getValueType(),
13819 return DAG.getNode(X86ISD::PSHUFHW, dl, Op.getValueType(),
13828 return DAG.getNode(X86ISD::PSIGN, dl, Op.getValueType(),
13832 return DAG.getNode(X86ISD::INSERTPS, dl, Op.getValueType(),
13839 return DAG.getNode(X86ISD::VPERM2X128, dl, Op.getValueType(),
13846 return DAG.getNode(X86ISD::VPERMV, dl, Op.getValueType(),
13853 return DAG.getNode(ISD::FSQRT, dl, Op.getValueType(), Op.getOperand(1));
13915 SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
13917 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
13918 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
13923 SDValue LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(1));
13924 SDValue RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1, Op.getOperand(2));
13926 SDValue Test = DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
13927 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i1, CC, Test);
13928 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
13974 return DAG.getNode(Opcode, dl, Op.getValueType(),
14082 SDValue PCMP = DAG.getNode(Opcode, dl, VTs, NewOps);
14083 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
14085 SDValue(PCMP.getNode(), 1));
14086 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
14099 return DAG.getNode(Opcode, dl, VTs, NewOps);
14190 return DAG.getNode(Opc, dl, Op.getValueType(), Op.getOperand(1),
14211 MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
14239 MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
14262 MaskInReg = DAG.getNode(ISD::BITCAST, dl, MaskVT, Mask);
14282 SDValue rd = DAG.getNode(X86ISD::RDPMC_DAG, DL, Tys, Chain);
14300 SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
14302 Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
14309 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
14321 SDValue rd = DAG.getNode(Opcode, DL, Tys, N->getOperand(0));
14354 SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
14356 Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
14363 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops);
14372 getReadTimeStampCounter(Op.getNode(), DL, X86ISD::RDTSC_DAG, DAG, Subtarget,
14492 SDValue Result = DAG.getNode(Intr.Opc0, dl, VTs, Op.getOperand(0));
14499 SDValue(Result.getNode(), 1) };
14500 SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
14505 return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
14506 SDValue(Result.getNode(), 2));
14546 getReadTimeStampCounter(Op.getNode(), dl, Intr.Opc0, DAG, Subtarget, Results);
14552 getReadPerformanceCounter(Op.getNode(), dl, DAG, Subtarget, Results);
14558 SDValue InTrans = DAG.getNode(X86ISD::XTEST, dl, VTs, Op.getOperand(0));
14559 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
14562 SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
14563 return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
14564 Ret, SDValue(InTrans.getNode(), 1));
14588 DAG.getNode(ISD::ADD, dl, PtrVT,
14656 SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
14658 StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
14663 return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
14670 return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
14678 return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
14716 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
14725 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
14731 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
14739 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
14746 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
14752 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
14801 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
14803 Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
14813 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
14820 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
14826 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
14832 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains);
14883 DAG.getNode(ISD::SRL, DL, MVT::i16,
14884 DAG.getNode(ISD::AND, DL, MVT::i16,
14888 DAG.getNode(ISD::SRL, DL, MVT::i16,
14889 DAG.getNode(ISD::AND, DL, MVT::i16,
14894 DAG.getNode(ISD::AND, DL, MVT::i16,
14895 DAG.getNode(ISD::ADD, DL, MVT::i16,
14896 DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
14900 return DAG.getNode((VT.getSizeInBits() < 16 ?
14914 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
14919 Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
14928 Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops);
14931 Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
14934 Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
14948 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
14953 Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
14956 Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
14959 Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
14971 Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
14980 return DAG.getNode(X86ISD::CMOV, dl, VT, Ops);
15007 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
15008 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
15009 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
15049 SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
15051 SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
15053 Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
15054 Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
15082 A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
15083 B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
15084 Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
15085 Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
15087 SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
15088 SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
15089 SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
15094 SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
15095 return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
15147 return DAG.getNode(ISD::BITCAST, dl, VT, CallInfo.first);
15170 SDValue Mul1 = DAG.getNode(ISD::BITCAST, dl, VT,
15171 DAG.getNode(Opcode, dl, MulVT, Op0, Op1));
15172 SDValue Mul2 = DAG.getNode(ISD::BITCAST, dl, VT,
15173 DAG.getNode(Opcode, dl, MulVT, Hi0, Hi1));
15194 SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
15195 DAG.getNode(ISD::SRA, dl, VT, Op0, ShAmt), Op1);
15196 SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
15197 DAG.getNode(ISD::SRA, dl, VT, Op1, ShAmt), Op0);
15199 SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
15200 Highs = DAG.getNode(ISD::SUB, dl, VT, Highs, Fixup);
15203 return DAG.getNode(ISD::MERGE_VALUES, dl, Op.getValueType(), Highs, Lows);
15240 SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
15245 return DAG.getNode(ISD::AND, dl, VT, SHL,
15246 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
15253 SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
15258 return DAG.getNode(ISD::AND, dl, VT, SRL,
15259 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
15265 return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
15269 SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
15272 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
15273 Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
15274 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
15286 SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
15291 return DAG.getNode(ISD::AND, dl, VT, SHL,
15292 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
15299 SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
15304 return DAG.getNode(ISD::AND, dl, VT, SRL,
15305 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V));
15311 return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
15315 SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
15318 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, V);
15319 Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
15320 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
15433 if (!BaseShAmt.getNode())
15434 BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Amt,
15439 if (BaseShAmt.getNode()) {
15441 BaseShAmt = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BaseShAmt);
15443 BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
15510 return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
15512 return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
15514 return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
15533 if (V.getNode())
15537 if (V.getNode())
15562 ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
15585 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Elts);
15586 return DAG.getNode(ISD::MUL, dl, VT, R, BV);
15591 Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
15593 Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
15594 Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
15595 Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
15596 return DAG.getNode(ISD::MUL, dl, VT, Op, R);
15612 ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
15658 SDValue Shift1 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat1);
15661 SDValue Shift2 = DAG.getNode(Op->getOpcode(), dl, VT, R, Splat2);
15664 SDValue BitCast1 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift1);
15665 SDValue BitCast2 = DAG.getNode(ISD::BITCAST, dl, CastVT, Shift2);
15668 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
15676 Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
15677 Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
15681 SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
15682 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
15688 SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
15690 M = DAG.getNode(ISD::BITCAST, dl, VT, M);
15691 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
15694 Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
15695 OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
15696 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
15699 M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
15701 M = DAG.getNode(ISD::BITCAST, dl, VT, M);
15702 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
15705 Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
15706 OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
15707 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
15710 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
15711 DAG.getNode(ISD::ADD, dl, VT, R, R), R);
15722 R = DAG.getNode(ExtOpc, dl, NewVT, R);
15723 Amt = DAG.getNode(ISD::ANY_EXTEND, dl, NewVT, Amt);
15724 return DAG.getNode(ISD::TRUNCATE, dl, VT,
15725 DAG.getNode(Op.getOpcode(), dl, NewVT, R, Amt));
15749 Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt1Csts);
15750 Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Amt2Csts);
15758 V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
15759 V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
15762 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
15773 SDNode *N = Op.getNode();
15820 SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
15823 DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
15825 SDValue(Sum.getNode(), 2));
15827 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
15833 SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
15836 DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
15838 SDValue(Sum.getNode(), 1));
15840 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
15879 LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
15880 LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
15882 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
15895 if (Tmp1.getNode()) {
15904 return DAG.getNode(X86ISD::VSEXT, dl, VT, Tmp1Op0.getOperand(0));
15934 return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
15952 return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
15987 SDValue Success = DAG.getNode(X86ISD::SETCC, DL, Op->getValueType(1),
16016 Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, InVec,
16025 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, Elts);
16026 SDValue ToV2F64 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, BV);
16027 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, ToV2F64,
16049 SDNode *Node = Op.getNode();
16052 SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
16064 SDNode *Node = Op.getNode();
16089 EVT VT = Op.getNode()->getSimpleValueType(0);
16108 return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
16110 return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
16158 SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
16160 SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
16163 return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
16315 if (FIST.getNode()) {
16318 if (StackSlot.getNode())
16332 SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
16336 SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
16337 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
16338 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
16339 Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
16340 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
16341 Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
16347 SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
16376 cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
16378 cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
16387 swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
16389 swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
16416 DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
16420 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF));
16455 SDValue Expanded = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
16457 SDValue ToVecInt = DAG.getNode(ISD::BITCAST, dl, WiderVT, Expanded);
16468 Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT,
16471 Results.push_back(DAG.getNode(ISD::BUILD_VECTOR, dl, DstVT, Elts));
18356 if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
18384 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
18385 SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
18387 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
18388 SDValue(ResNode.getNode(), 1));
18391 return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
18430 bool HaveMask = getTargetShuffleMask(N.getNode(), N.getSimpleValueType(), Mask, IsUnary);
18507 !V->isOnlyUserOf(V.getOperand(0).getNode()))
18544 V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
18549 if (Old.getNode() == V.getNode()) {
18550 DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo=*/true);
18559 DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
18633 V = DAG.getNode(V.getOpcode(), DL, MVT::v8i16, V.getOperand(0),
18641 DCI.CombineTo(Old.getNode(), V, /*AddTo*/ true);
18666 return DCI.CombineTo(N.getNode(), N.getOperand(0), /*AddTo*/ true);
18689 V = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, V);
18690 DCI.AddToWorklist(V.getNode());
18691 V = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V,
18693 DCI.AddToWorklist(V.getNode());
18694 return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, V);
18729 V = DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, D.getOperand(0));
18730 DCI.AddToWorklist(V.getNode());
18731 return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
18795 SDValue Op1 = DAG.getNode(ISD::FNEG, dl, VT, N1->getOperand(1));
18796 SDValue Sub = DAG.getNode(ISD::FSUB, dl, VT, Op0, Op1);
18797 SDValue Add = DAG.getNode(ISD::FADD, dl, VT, Op0, Op1);
18855 SDValue BC00 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(0));
18856 SDValue BC01 = DAG.getNode(ISD::BITCAST, dl, VT, BC0.getOperand(1));
18857 SDValue NewBinOp = DAG.getNode(BC0.getOpcode(), dl, VT, BC00, BC01);
18875 if (LD.getNode())
18881 if (Shuffle.getNode())
18935 if (!getTargetShuffleMask(InVec.getNode(), VT.getSimpleVT(), ShuffleMask,
18951 if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
18958 if (!ISD::isNormalLoad(LdNode.getNode()))
18987 Shuffle = DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
18988 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
18998 if (NewOp.getNode())
19005 if (InputVector.getNode()->getOpcode() == llvm::ISD::BITCAST &&
19006 InputVector.getNode()->getOperand(0).getValueType() == MVT::x86mmx &&
19008 return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
19010 InputVector.getNode()->getOperand(0));
19022 for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
19023 UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
19073 SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
19190 if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
19363 return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
19377 Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, OpVT, Cond);
19378 DCI.AddToWorklist(Cond.getNode());
19379 return DAG.getNode(N->getOpcode(), DL, OpVT, Cond, LHS, RHS);
19405 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
19409 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
19412 return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
19419 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
19423 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
19425 return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
19454 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
19458 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
19462 Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
19467 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
19501 return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
19520 if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
19523 } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
19527 if (Other.getNode() && Other->getNumOperands() == 2 &&
19537 return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
19549 return DAG.getNode(
19559 ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
19563 return DAG.getNode(
19587 LHS = DAG.getNode(Opc, DL, LHS1.getValueType(), LHS1, RHS1);
19588 RHS = DAG.getNode(Opc, DL, LHS2.getValueType(), LHS2, RHS2);
19591 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LHS, RHS);
19593 return DAG.getNode(Opc, DL, VT, LHS, RHS);
19606 bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
19607 bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
19612 bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
19613 bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
19633 Ret = DAG.getNode(ISD::OR, DL, CondVT, Cond,
19634 DAG.getNode(ISD::BITCAST, DL, CondVT, RHS));
19636 Ret = DAG.getNode(ISD::AND, DL, CondVT, Cond,
19637 DAG.getNode(ISD::BITCAST, DL, CondVT, LHS));
19639 return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
19708 SDValue NewA = DAG.getNode(ISD::BITCAST, DL, NVT, LHS);
19709 SDValue NewB = DAG.getNode(ISD::BITCAST, DL, NVT, RHS);
19712 return DAG.getNode(ISD::BITCAST, DL, VT, Select);
19769 if (Shuffle.getNode())
19794 (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
19937 if (Flags.getNode() &&
19942 return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(), Ops);
19962 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
19966 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
19969 Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
19979 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
19983 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
19985 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
20017 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
20020 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
20024 Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
20029 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
20072 return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops);
20120 if (ISD::isBuildVectorAllZeros(Mask.getNode()))
20123 if (ISD::isBuildVectorAllOnes(Mask.getNode()))
20177 return DAG.getNode(ISD::SRA, SDLoc(N), VT, Op0, Splat);
20226 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
20229 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
20233 NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
20236 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
20265 return DAG.getNode(ISD::AND, SDLoc(N), VT,
20281 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
20323 if (V.getNode()) return V;
20329 if (V.getNode()) return V;
20395 SDValue FSetCC = DAG.getNode(X86ISD::FSETCC, DL, MVT::i1, CMP00,
20398 return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0),
20402 SDValue OnesOrZeroesF = DAG.getNode(X86ISD::FSETCC, DL,
20415 SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
20417 SDValue Vector32 = DAG.getNode(ISD::BITCAST, DL, MVT::v4f32,
20419 OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
20424 SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, IntVT, OnesOrZeroesF);
20425 SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
20427 SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
20447 N = N->getOperand(0).getNode();
20458 ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
20459 ISD::isBuildVectorAllOnes(V2.getNode()))
20520 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
20523 N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, C);
20529 SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
20538 return DAG.getNode(ISD::AND, DL, VT,
20542 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
20557 if (R.getNode())
20578 return DAG.getNode(X86ISD::BEXTR, DL, VT, N0.getOperand(0),
20600 //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
20601 CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
20602 return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
20606 //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
20607 CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
20608 return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
20620 if (R.getNode())
20647 if (!Y.getNode())
20683 ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
20687 Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
20688 return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
20696 X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
20697 Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
20698 Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
20699 Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
20700 return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
20753 if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
20756 return DAG.getNode(Opc, DL, VT,
20758 DAG.getNode(ISD::TRUNCATE, DL,
20765 return DAG.getNode(Opc, DL, VT,
20767 DAG.getNode(ISD::TRUNCATE, DL,
20797 SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
20802 SDValue(Neg.getNode(), 1) };
20803 return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue), Ops);
20817 if (RV.getNode())
20854 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
20859 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
20952 Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
20954 Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
20957 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
20960 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
20964 SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
20970 SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
20989 Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
20994 Shuff = DAG.getNode(ISD::SRA, dl, RegVT, Shuff,
21010 Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
21046 SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
21055 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
21084 SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
21117 SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
21125 SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
21131 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
21135 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
21157 SDNode* LdVal = St->getValue().getNode();
21161 SDNode* ChainVal = St->getChain().getNode();
21170 if (ChainVal->getOperand(i).getNode() == LdVal) {
21201 NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
21211 SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
21228 NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, Ops);
21232 HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
21244 return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
21306 ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
21324 ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
21338 if (!A.getNode() && !B.getNode())
21356 (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
21357 (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
21370 LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
21371 RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
21386 return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
21401 return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
21438 return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
21495 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
21523 if (!ISD::isNormalLoad(N00.getNode()))
21527 SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
21529 return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
21547 if (R.getNode())
21591 return DAG.getNode(Opcode, dl, VT, A, B, C);
21613 return DAG.getNode(ISD::AND, dl, VT,
21614 DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
21625 return DAG.getNode(ISD::AND, dl, VT,
21626 DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
21633 if (R.getNode())
21653 SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
21661 SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
21670 bool IsVZero0 = ISD::isBuildVectorAllZeros(LHS.getNode());
21675 bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
21717 SDValue LoadScalarToVector = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Ld);
21720 return DAG.getNode(X86ISD::INSERTPS, dl, VT, N->getOperand(0),
21730 return DAG.getNode(ISD::AND, DL, VT,
21731 DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
21735 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1,
21736 DAG.getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
21758 SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
21759 EFLAGS.getNode()->getVTList(),
21761 SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
21775 if (Flags.getNode()) {
21777 return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
21797 if (Flags.getNode()) {
21799 return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
21815 SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
21816 return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
21822 LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
21825 ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
21851 SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
21852 DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
21889 SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
21894 return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
21897 return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
21913 return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
21933 SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
21936 return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
21946 return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
21963 return DAG.getNode(X86ISD::VZEXT, SDLoc(N), N->getValueType(0),
22082 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
22083 UE = Op.getNode()->use_end(); UI != UE; ++UI) {
22544 if (Result.getNode()) {
