Lines Matching full:getnode
86 return DAG.getNode(ISD::BUILD_VECTOR, dl, ResultVT,
90 SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
137 return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
1688 return DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy());
1800 ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
1802 ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
1804 ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
1806 ValToCopy = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), ValToCopy);
1829 ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
1840 ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ValToCopy);
1841 ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
1846 ValToCopy = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32,ValToCopy);
1883 if (Flag.getNode())
1886 return DAG.getNode(X86ISD::RET_FLAG, dl,
1983 Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
2212 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
2215 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
2218 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
2223 ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
2225 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
2255 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
2344 SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(), RSFIN,
2378 MemOps.push_back(DAG.getNode(X86ISD::VASTART_SAVE_XMM_REGS, dl,
2384 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2423 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, PtrOff);
2446 return SDValue(OutRetAddr.getNode(), 1);
2576 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
2579 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
2584 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
2585 Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
2588 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
2591 Arg = DAG.getNode(ISD::BITCAST, dl, RegVT, Arg);
2622 if (StackPtr.getNode() == 0)
2631 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2639 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), getPointerTy())));
2711 if (StackPtr.getNode() == 0)
2715 Source = DAG.getNode(ISD::ADD, dl, getPointerTy(), StackPtr, Source);
2731 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2802 Callee = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Callee);
2858 if (InFlag.getNode())
2868 return DAG.getNode(X86ISD::TC_RETURN, dl, NodeTys, &Ops[0], Ops.size());
2871 Chain = DAG.getNode(X86ISD::CALL, dl, NodeTys, &Ops[0], Ops.size());
3228 return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
3232 return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
3269 return DAG.getNode(Opc, dl, VT, V1);
3283 return DAG.getNode(Opc, dl, VT, V1, DAG.getConstant(TargetMask, MVT::i8));
3295 return DAG.getNode(Opc, dl, VT, V1, V2,
3313 return DAG.getNode(Opc, dl, VT, V1, V2);
3432 if (ISD::isNON_EXTLoad(LHS.getNode()) &&
3433 !ISD::isNON_EXTLoad(RHS.getNode())) {
3853 SDValue UndefNode = DAG.getNode(ISD::UNDEF, dl, VT);
4243 if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4248 cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4262 if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4266 cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4396 if (!isa<ConstantSDNode>(N->getOperand(1).getNode()))
4400 cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
4411 if (!isa<ConstantSDNode>(N->getOperand(2).getNode()))
4415 cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
4529 N = N->getOperand(0).getNode();
4545 switch (N->getOperand(i).getNode()->getOpcode()) {
4614 if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V2.getNode()))
4621 if (Opc == ISD::UNDEF || ISD::isBuildVectorAllZeros(V1.getNode()))
4643 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4646 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4f32, Cst, Cst, Cst, Cst);
4652 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops,
4659 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8f32, Ops,
4665 return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4681 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32, Ops,
4684 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4688 Vec = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, Cst, Cst, Cst, Cst);
4692 return DAG.getNode(ISD::BITCAST, dl, VT, Vec);
4768 V = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V);
4779 V = DAG.getNode(ISD::BITCAST, dl, MVT::v8f32, V);
4785 return DAG.getNode(ISD::BITCAST, dl, VT, V);
4821 V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, SrcVT, V1, V1);
4948 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
4967 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
5003 if (!Elt.getNode())
5158 LastElt = DAG.getNode(ISD::ZERO_EXTEND, dl,
5162 ThisElt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Op.getOperand(i));
5163 ThisElt = DAG.getNode(ISD::SHL, dl, MVT::i16,
5166 ThisElt = DAG.getNode(ISD::OR, dl, MVT::i16, ThisElt, LastElt);
5170 if (ThisElt.getNode())
5171 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, V, ThisElt,
5176 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V);
5202 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
5219 SrcOp = DAG.getNode(ISD::BITCAST, dl, ShVT, SrcOp);
5220 return DAG.getNode(ISD::BITCAST, dl, VT,
5221 DAG.getNode(Opc, dl, ShVT, SrcOp,
5280 Ptr = DAG.getNode(ISD::ADD, SDLoc(Ptr), Ptr.getValueType(),
5321 if (!Elt.getNode() ||
5322 (Elt.getOpcode() != ISD::UNDEF && !ISD::isNON_EXTLoad(Elt.getNode())))
5325 if (Elt.getNode()->getOpcode() == ISD::UNDEF)
5327 LDBase = cast<LoadSDNode>(Elt.getNode());
5356 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5358 SDValue(NewLd.getNode(), 1));
5360 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5361 SDValue(NewLd.getNode(), 1));
5382 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
5383 SDValue(LDBase, 1), SDValue(ResNode.getNode(), 1));
5385 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(LDBase, 1),
5386 SDValue(ResNode.getNode(), 1));
5389 return DAG.getNode(ISD::BITCAST, DL, VT, ResNode);
5422 if (!isSplatVector(Op.getNode()))
5455 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Sc);
5501 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5505 bool IsLoad = ISD::isNormalLoad(Ld.getNode());
5511 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5518 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5524 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5573 if (VecIn1.getNode() == 0)
5576 if (VecIn2.getNode() == 0)
5591 if (VecIn1.getNode() == 0)
5594 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
5598 NV = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, NV, Op.getOperand(Idx),
5614 if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5618 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
5622 if (ISD::isBuildVectorAllOnes(Op.getNode())) {
5626 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT,
5645 SDValue FullMask = DAG.getNode(ISD::BITCAST, dl, MVT::v16i1,
5647 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, FullMask,
5651 if (!isSplatVector(Op.getNode()))
5683 SDValue Bit1 = DAG.getNode(ISD::AND, dl, InVT, In, DAG.getConstant(1, InVT));
5691 SDValue CmovOp = DAG.getNode(X86ISD::CMOV, dl, MVT::i16,
5693 return DAG.getNode(ISD::BITCAST, dl, VT, CmovOp);
5699 SDValue CmovOp = DAG.getNode(X86ISD::CMOV, dl, MVT::i32,
5701 CmovOp = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, CmovOp);
5702 return DAG.getNode(ISD::BITCAST, dl, VT, CmovOp);
5720 if (ISD::isBuildVectorAllZeros(Op.getNode())) {
5732 if (Subtarget->hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
5740 if (Broadcast.getNode())
5790 Item = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Item);
5791 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Item);
5804 return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5814 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5820 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, ZeroVec,
5824 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5830 Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
5831 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Item);
5839 return DAG.getNode(ISD::BITCAST, dl, VT, Item);
5849 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
5863 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
5883 if (Op.getNode()->isOnlyUserOf(Item.getNode()))
5904 SDValue Lower = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[0], NumElems/2);
5905 SDValue Upper = DAG.getNode(ISD::BUILD_VECTOR, dl, HVT, &V[NumElems / 2],
5917 SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
5928 if (V.getNode()) return V;
5934 if (V.getNode()) return V;
5945 V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
5984 if (LD.getNode())
5989 if (Sh.getNode())
5996 Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
6002 Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
6013 V[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
6116 V1 = DAG.getNode(ISD::BITCAST, dl, VT, V1);
6117 V2 = DAG.getNode(ISD::BITCAST, dl, VT, V2);
6120 SDValue Ret = DAG.getNode(X86ISD::BLENDI, dl, BlendVT, V1, V2,
6122 return DAG.getNode(ISD::BITCAST, dl, VT, Ret);
6205 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1),
6206 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2), &MaskV[0]);
6207 NewV = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, NewV);
6248 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6279 V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V1);
6280 V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
6281 DAG.getNode(ISD::BUILD_VECTOR, dl,
6284 return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6296 V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, V2);
6297 V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
6298 DAG.getNode(ISD::BUILD_VECTOR, dl,
6300 V1 = DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
6301 return DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6322 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6346 ShuffleVectorSDNode *SVOp = cast<ShuffleVectorSDNode>(NewV.getNode());
6371 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V1,
6373 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, V2,
6375 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, ExtOp,
6419 V1 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V1,
6420 DAG.getNode(ISD::BUILD_VECTOR, dl,
6426 ISD::isBuildVectorAllZeros(V2.getNode()))
6437 V2 = DAG.getNode(X86ISD::PSHUFB, dl, MVT::v16i8, V2,
6438 DAG.getNode(ISD::BUILD_VECTOR, dl,
6440 return DAG.getNode(ISD::OR, dl, MVT::v16i8, V1, V2);
6446 V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
6447 V2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
6468 InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
6470 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
6479 InsElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16, Elt1Src,
6482 InsElt = DAG.getNode(ISD::SHL, dl, MVT::i16, InsElt,
6486 InsElt = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt,
6494 SDValue InsElt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
6497 InsElt0 = DAG.getNode(ISD::SRL, dl, MVT::i16, InsElt0,
6501 InsElt0 = DAG.getNode(ISD::AND, dl, MVT::i16, InsElt0,
6503 InsElt = Elt1 >= 0 ? DAG.getNode(ISD::OR, dl, MVT::i16, InsElt, InsElt0)
6506 NewV = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v8i16, NewV, InsElt,
6509 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, NewV);
6524 bool V1IsAllZero = ISD::isBuildVectorAllZeros(V1.getNode());
6525 bool V2IsAllZero = ISD::isBuildVectorAllZeros(V2.getNode());
6552 return DAG.getNode(X86ISD::PSHUFB, dl, MVT::v32i8, V1,
6553 DAG.getNode(ISD::BUILD_VECTOR, dl,
6595 SDValue V1 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(0));
6596 SDValue V2 = DAG.getNode(ISD::BITCAST, dl, NewVT, SVOp->getOperand(1));
6607 if (!isScalarLoadToVector(SrcOp.getNode(), &LD))
6619 return DAG.getNode(ISD::BITCAST, dl, VT,
6620 DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6621 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
6629 return DAG.getNode(ISD::BITCAST, dl, VT,
6630 DAG.getNode(X86ISD::VZEXT_MOVL, dl, OpVT,
6631 DAG.getNode(ISD::BITCAST, dl,
6641 if (NewOp.getNode())
6719 SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
6725 Output[l] = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, &SVOps[0],
6746 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Output[0], Output[1]);
6910 V1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
6911 return DAG.getNode(ISD::BITCAST, dl, VT,
6929 return DAG.getNode(ISD::BITCAST, dl, VT,
6931 DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V1),
6932 DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, V2), DAG));
7076 (!ISD::isNormalLoad(V.getNode()) || !V.hasOneUse())) {
7086 V = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVecVT, V,
7089 V1 = DAG.getNode(ISD::BITCAST, DL, V1.getValueType(), V);
7093 return DAG.getNode(ISD::BITCAST, DL, VT,
7094 DAG.getNode(X86ISD::VZEXT, DL, NVT, V1));
7112 if (Broadcast.getNode())
7118 if (NewOp.getNode())
7126 if (NewOp.getNode())
7127 return DAG.getNode(ISD::BITCAST, dl, VT, NewOp);
7132 if (ISD::isBuildVectorAllZeros(V2.getNode())) {
7134 if (NewOp.getNode()) {
7141 } else if (ISD::isBuildVectorAllZeros(V1.getNode())) {
7143 if (NewOp.getNode()) {
7198 if (NewOp.getNode())
7261 if (ISD::isBuildVectorAllZeros(V1.getNode()))
7289 ShouldXformToMOVLP(V1.getNode(), V2.getNode(), M, VT))
7302 V1IsSplat = isSplatVector(V1.getNode());
7303 V2IsSplat = isSplatVector(V2.getNode());
7413 if (BlendOp.getNode())
7421 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v8i32,
7424 return DAG.getNode(X86ISD::VPERMV, dl, VT,
7425 DAG.getNode(ISD::BITCAST, dl, VT, Mask), V1);
7441 if (NewOp.getNode())
7447 if (NewOp.getNode())
7453 if (NewOp.getNode())
7477 SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
7479 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
7481 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7488 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
7489 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7490 DAG.getNode(ISD::BITCAST, dl,
7494 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
7496 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Extract,
7498 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7509 SDNode *User = *Op.getNode()->use_begin();
7516 getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7517 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32,
7520 return DAG.getNode(ISD::BITCAST, dl, MVT::f32, Extract);
7556 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
7564 if (Res.getNode())
7574 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
7575 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
7576 DAG.getNode(ISD::BITCAST, dl,
7581 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, EltVT,
7583 SDValue Assert = DAG.getNode(ISD::AssertZext, dl, EltVT, Extract,
7585 return DAG.getNode(ISD::TRUNCATE, dl, VT, Assert);
7598 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
7617 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
7649 N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7652 return DAG.getNode(Opc, dl, VT, N0, N1, N2);
7666 N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
7667 return DAG.getNode(X86ISD::INSERTPS, dl, VT, N0, N1, N2);
7701 V = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, V.getValueType(), V, N1,
7718 N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
7721 return DAG.getNode(X86ISD::PINSRW, dl, VT, N0, N1, N2);
7740 Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
7748 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i64, Op.getOperand(0));
7750 SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
7752 return DAG.getNode(ISD::BITCAST, dl, OpVT,
7753 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,AnyExt));
7788 SDLoc dl(Op.getNode());
7789 SDValue Vec = Op.getNode()->getOperand(0);
7790 SDValue SubVec = Op.getNode()->getOperand(1);
7791 SDValue Idx = Op.getNode()->getOperand(2);
7793 if ((Op.getNode()->getValueType(0).is256BitVector() ||
7794 Op.getNode()->getValueType(0).is512BitVector()) &&
7795 SubVec.getNode()->getValueType(0).is128BitVector() &&
7801 if (Op.getNode()->getValueType(0).is512BitVector() &&
7802 SubVec.getNode()->getValueType(0).is256BitVector() &&
7839 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7842 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7843 DAG.getNode(X86ISD::GlobalBaseReg,
7871 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7875 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7876 DAG.getNode(X86ISD::GlobalBaseReg,
7909 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
7914 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
7915 DAG.getNode(X86ISD::GlobalBaseReg,
7943 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7945 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7949 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7950 DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7977 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
7979 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
7983 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
7984 DAG.getNode(X86ISD::GlobalBaseReg, dl, getPointerTy()),
7997 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
8027 Chain = DAG.getNode(CallType, dl, NodeTys, Ops, array_lengthof(Ops));
8030 Chain = DAG.getNode(CallType, dl, NodeTys, Ops, array_lengthof(Ops));
8047 DAG.getNode(X86ISD::GlobalBaseReg,
8080 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT), InFlag);
8095 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
8098 return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
8139 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
8143 Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
8144 DAG.getNode(X86ISD::GlobalBaseReg, SDLoc(), PtrVT),
8155 return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
8202 SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
8206 Offset = DAG.getNode(ISD::ADD, DL, getPointerTy(),
8207 DAG.getNode(X86ISD::GlobalBaseReg,
8216 Chain = DAG.getNode(X86ISD::TLSCALL, DL, NodeTys, Args, 2);
8277 IDX = DAG.getNode(ISD::SHL, dl, getPointerTy(), IDX, Scale);
8279 SDValue res = DAG.getNode(ISD::ADD, dl, getPointerTy(), ThreadPointer, IDX);
8287 SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), TGA);
8291 return DAG.getNode(ISD::ADD, dl, getPointerTy(), res, Offset);
8308 SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
8314 Tmp2 = DAG.getNode(X86ISD::SHLD, dl, VT, ShOpHi, ShOpLo, ShAmt);
8315 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
8317 Tmp2 = DAG.getNode(X86ISD::SHRD, dl, VT, ShOpLo, ShOpHi, ShAmt);
8318 Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, ShAmt);
8321 SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
8323 SDValue Cond = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
8332 Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
8333 Lo = DAG.getNode
8335 Lo = DAG.getNode(X86ISD::CMOV, dl, VT, Ops0, 4);
8336 Hi = DAG.getNode(X86ISD::CMOV, dl, VT, Ops1, 4);
8472 SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
8478 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, XR1),
8484 SDValue XR2F = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Unpck1);
8485 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
8490 Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
8492 SDValue S2F = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Sub);
8495 Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64,
8496 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Shuffle),
8500 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
8513 SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
8519 Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
8520 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Load),
8524 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64,
8525 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
8526 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
8528 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
8529 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
8531 Or = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
8532 DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or),
8536 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
8542 return DAG.getNode(ISD::FP_ROUND, dl, DestVT, Sub,
8545 return DAG.getNode(ISD::FP_EXTEND, dl, DestVT, Sub);
8563 return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(),
8564 DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N0));
8579 return DAG.getNode(ISD::SINT_TO_FP, dl, Op.getValueType(), N0);
8594 SDValue OffsetSlot = DAG.getNode(ISD::ADD, dl,
8642 SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
8644 FudgePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(), FudgePtr, Offset);
8652 SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
8653 return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add, DAG.getIntPtrConstant(0));
8736 SDValue ftol = DAG.getNode(X86ISD::WIN_FTOL, DL,
8745 ? DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Ops, array_lengthof(Ops))
8776 return DAG.getNode(X86ISD::VZEXT_MOVL, dl, VT, In);
8787 OpLo = DAG.getNode(ISD::BITCAST, dl, HVT, OpLo);
8788 OpHi = DAG.getNode(ISD::BITCAST, dl, HVT, OpHi);
8790 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
8797 if (Res.getNode())
8812 if (Res.getNode())
8824 return DAG.getNode(X86ISD::VZEXT, DL, VT, In);
8826 SDValue Lo = DAG.getNode(X86ISD::VZEXT, DL, MVT::v4i32, In);
8828 SDValue Hi = DAG.getNode(X86ISD::VZEXT, DL, MVT::v4i32,
8833 return DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v8i32, Lo, Hi);
8846 In = DAG.getNode(ISD::BITCAST, DL, MVT::v8i32, In);
8849 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
8854 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
8856 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
8859 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
8860 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
8876 In = DAG.getNode(ISD::BITCAST, DL, MVT::v32i8, In);
8891 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v32i8,
8893 In = DAG.getNode(X86ISD::PSHUFB, DL, MVT::v32i8, In, BV);
8894 In = DAG.getNode(ISD::BITCAST, DL, MVT::v4i64, In);
8899 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
8901 return DAG.getNode(ISD::BITCAST, DL, VT, In);
8904 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
8907 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
8910 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpLo);
8911 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, OpHi);
8921 OpLo = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpLo);
8922 OpHi = DAG.getNode(ISD::BITCAST, DL, MVT::v4i32, OpHi);
8927 return DAG.getNode(ISD::BITCAST, DL, MVT::v8i16, res);
8947 DAG.getNode(ISD::BITCAST, DL, NVT, In),
8949 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, V,
8958 return DAG.getNode(ISD::TRUNCATE, SDLoc(Op), VT,
8959 DAG.getNode(ISD::FP_TO_SINT, SDLoc(Op),
8968 if (FIST.getNode() == 0) return Op;
8970 if (StackSlot.getNode())
8985 assert(FIST.getNode() && "Unexpected failure");
8987 if (StackSlot.getNode())
9005 return DAG.getNode(X86ISD::VFPEXT, DL, VT,
9006 DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
9035 return DAG.getNode(ISD::BITCAST, dl, VT,
9036 DAG.getNode(ISD::AND, dl, ANDVT,
9037 DAG.getNode(ISD::BITCAST, dl, ANDVT,
9039 DAG.getNode(ISD::BITCAST, dl, ANDVT, Mask)));
9041 return DAG.getNode(X86ISD::FAND, dl, VT, Op.getOperand(0), Mask);
9069 return DAG.getNode(ISD::BITCAST, dl, VT,
9070 DAG.getNode(ISD::XOR, dl, XORVT,
9071 DAG.getNode(ISD::BITCAST, dl, XORVT,
9073 DAG.getNode(ISD::BITCAST, dl, XORVT, Mask)));
9076 return DAG.getNode(X86ISD::FXOR, dl, VT, Op.getOperand(0), Mask);
9089 Op1 = DAG.getNode(ISD::FP_EXTEND, dl, VT, Op1);
9094 Op1 = DAG.getNode(ISD::FP_ROUND, dl, VT, Op1, DAG.getIntPtrConstant(1));
9119 SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, SrcVT, Op1, Mask1);
9124 SignBit = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, SignBit);
9125 SignBit = DAG.getNode(X86ISD::FSRL, dl, MVT::v2f64, SignBit,
9127 SignBit = DAG.getNode
9128 SignBit = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, SignBit,
9152 SDValue Val = DAG.getNode(X86ISD::FAND, dl, VT, Op0, Mask2);
9155 return DAG.getNode(X86ISD::FOR, dl, VT, Val, SignBit);
9164 SDValue xFGETSIGN = DAG.getNode(X86ISD::FGETSIGNx86, dl, VT, N0,
9166 return DAG.getNode(ISD::AND, dl, VT, xFGETSIGN, DAG.getConstant(1, VT));
9181 SDNode *N = Op.getNode();
9247 VecIns[i] = DAG.getNode(ISD::BITCAST, DL, TestVT, VecIns[i]);
9255 VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
9258 return DAG.getNode(X86ISD::PTEST, DL, MVT::i32,
9290 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
9333 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9334 UE = Op.getNode()->use_end(); UI != UE; ++UI)
9341 dyn_cast<ConstantSDNode>(ArithOp.getNode()->getOperand(1))) {
9365 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9366 UE = Op.getNode()->use_end(); UI != UE; ++UI) {
9392 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
9393 UE = Op.getNode()->use_end(); UI != UE; ++UI)
9406 if (EFLAGS.getNode())
9423 return SDValue(Op.getNode(), 1);
9451 SDValue V0 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(0));
9452 SDValue V1 = DAG.getNode(ISD::TRUNCATE, dl, VT, WideVal.getOperand(1));
9453 Op = DAG.getNode(ConvertedOp, dl, VT, V0, V1);
9460 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
9468 SDValue New = DAG.getNode(Opcode, dl, VTs, &Ops[0], NumOperands);
9470 return SDValue(New.getNode(), 1);
9486 SDValue Sub = DAG.getNode(X86ISD::SUB, dl, VTs,
9488 return SDValue(Sub.getNode(), 1);
9490 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
9509 SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
9510 SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
9511 SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
9513 SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
9514 return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
9569 if (LHS.getNode
9577 LHS = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, LHS);
9582 RHS = DAG.getNode(ISD::ANY_EXTEND, dl, LHS.getValueType(), RHS);
9584 SDValue BT = DAG.getNode(X86ISD::BT, dl, MVT::i32, LHS, RHS);
9586 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9663 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
9664 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1, CC),
9665 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2, CC));
9698 SDValue Cmp0 = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
9700 SDValue Cmp1 = DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
9702 return DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
9705 return DAG.getNode(X86ISD::CMPP, dl, VT, Op0, Op1,
9759 Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
9760 Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
9771 SB = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32,
9774 Op0 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op0, SB);
9775 Op1 = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Op1, SB);
9778 SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
9779 SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
9788 SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
9789 Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
9794 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
9803 Op0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op0);
9804 Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op1);
9807 SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
9812 Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
9817 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
9826 Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SB);
9827 Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SB);
9830 SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
9837 Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
9863 if (NewSetCC.getNode())
9883 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9895 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
9901 unsigned Opc = Op.getNode()->getOpcode();
9962 SDValue Cmp = DAG.getNode(Opcode, DL, VT, CondOp0, CondOp1,
9964 SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
9965 SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
9966 return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
9972 if (NewCond.getNode())
9999 SDValue Neg = DAG.getNode(X86ISD::SUB, DL, VTs,
10002 SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10004 SDValue(Neg.getNode(), 1));
10008 Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
10013 DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10021 Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
10079 SDValue X86Op = DAG.getNode(X86Opcode, DL, VTs, LHS, RHS);
10099 if (NewSetCC.getNode()) {
10122 SDValue Res = DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
10140 SDValue Cmov = DAG.getNode(X86ISD::CMOV, DL, VTs, T2, T1, CC, Cond);
10141 return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
10149 return DAG.getNode(X86ISD::CMOV, DL, VTs, Ops, array_lengthof(Ops));
10164 return DAG.getNode(X86ISD::VSEXT_MOVL, dl, VT, In);
10193 OpLo = DAG.getNode(X86ISD::VSEXT_MOVL, dl, HalfVT, OpLo);
10194 OpHi = DAG.getNode(X86ISD::VSEXT_MOVL, dl, HalfVT, OpHi);
10196 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
10250 if (NewCond.getNode())
10291 Cond = Cond.getNode()->getOperand(1);
10324 SDValue X86Op = DAG.getNode(X86Opcode, dl, VTs, LHS, RHS);
10344 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10358 Op.getNode()->hasOneUse()) {
10363 SDNode *User = *Op.getNode()->use_begin();
10375 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10403 if (Op.getNode()->hasOneUse()) {
10404 SDNode *User = *Op.getNode()->use_begin();
10416 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
10420 getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10434 if (Op.getNode()->hasOneUse()) {
10435 SDNode *User = *Op.getNode()->use_begin();
10446 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
10450 Chain = DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10470 if (NewSetCC.getNode()) {
10483 return DAG.getNode(X86ISD::BRCOND, dl, Op.getValueType(),
10530 SDValue Value = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
10542 Chain = DAG.getNode(X86ISD::WIN_ALLOCA, dl, NodeTys, Chain, Flag);
10586 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10595 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10605 FIN = DAG.getNode(ISD::ADD, DL, getPointerTy(),
10612 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
10622 assert(Op.getNode()->getNumOperands() == 4);
10629 EVT ArgVT = Op.getNode()->getValueType(0);
10716 return DAG.getNode(Opc, dl, VT, SrcOp,
10735 ShAmt = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v4i32, &ShOps[0], 4);
10742 ShAmt = DAG.getNode(ISD::BITCAST, dl, ShVT, ShAmt);
10743 return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
10846 SDValue Cond = DAG.getNode(Opc, dl, MVT::i32, LHS, RHS);
10847 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
10849 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
10855 return DAG.getNode(X86ISD::PMULUDQ, dl, Op.getValueType(),
10863 return DAG.getNode(X86ISD::SUBUS, dl, Op.getValueType(),
10911 return DAG.getNode(Opcode, dl, Op.getValueType(),
10976 return DAG.getNode(Opcode, dl, Op.getValueType(),
11005 return DAG.getNode(Opcode, dl, Op.getValueType(),
11040 return DAG.getNode(Opcode, dl, Op.getValueType(),
11046 return DAG.getNode(X86ISD::PSHUFB, dl, Op.getValueType(),
11055 return DAG.getNode(X86ISD::PSIGN, dl, Op.getValueType(),
11059 return DAG.getNode(X86ISD::INSERTPS, dl, Op.getValueType(),
11066 return DAG.getNode(X86ISD::VPERM2X128, dl, Op.getValueType(),
11073 return DAG.getNode(X86ISD::VPERMV, dl, Op.getValueType(),
11080 return DAG.getNode(ISD::FSQRT, dl, Op.getValueType(), Op.getOperand(1));
11142 SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
11144 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8, CC, Test);
11145 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11191 return DAG.getNode(Opcode, dl, Op.getValueType(),
11299 SDValue PCMP = DAG.getNode
11300 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
11302 SDValue(PCMP.getNode(), 1));
11303 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
11316 return DAG.getNode(Opcode, dl, VTs, NewOps.data(), NewOps.size());
11383 return DAG.getNode(Opc, dl, Op.getValueType(), Op.getOperand(1),
11408 SDValue Result = DAG.getNode(Opcode, dl, VTs, Op.getOperand(0));
11415 SDValue(Result.getNode(), 1) };
11416 SDValue isValid = DAG.getNode(X86ISD::CMOV, dl,
11421 return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
11422 SDValue(Result.getNode(), 2));
11428 SDValue InTrans = DAG.getNode(X86ISD::XTEST, dl, VTs, Op.getOperand(0));
11429 SDValue SetCC = DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
11432 SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
11433 return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(),
11434 Ret, SDValue(InTrans.getNode(), 1));
11454 DAG.getNode(ISD::ADD, dl, PtrVT,
11509 SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
11511 StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
11516 return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
11523 return DAG.getNode(X86ISD::EH_SJLJ_SETJMP, DL,
11531 return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
11569 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
11578 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
11584 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
11592 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
11599 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
11605 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 6);
11654 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
11656 Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
11666 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
11673 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
11679 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
11685 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, OutChains, 4);
11737 DAG.getNode(ISD::SRL, DL, MVT::i16,
11738 DAG.getNode(ISD::AND, DL, MVT::i16,
11742 DAG.getNode(ISD::SRL, DL, MVT::i16,
11743 DAG.getNode(ISD::AND, DL, MVT::i16,
11748 DAG.getNode(ISD::AND, DL, MVT::i16,
11749 DAG.getNode(ISD::ADD, DL, MVT::i16,
11750 DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
11754 return DAG.getNode((VT.getSizeInBits() < 16 ?
11768 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
11773 Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
11782 Op = DAG.getNode(X86ISD::CMOV, dl, OpVT, Ops, array_lengthof(Ops));
11785 Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
11788 Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
11802 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
11807 Op = DAG.getNode(X86ISD::BSR, dl, VTs, Op);
11810 Op = DAG.getNode(ISD::XOR, dl, OpVT, Op, DAG.getConstant(NumBits-1, OpVT));
11813 Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
11825 Op = DAG.getNode(X86ISD::BSF, dl, VTs, Op);
11834 return DAG.getNode(X86ISD::CMOV, dl, VT, Ops, array_lengthof(Ops));
11861 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
11862 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
11863 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
11903 SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, A, B);
11905 SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64, Aodds, Bodds);
11907 Evens = DAG.getNode(ISD::BITCAST, dl, VT, Evens);
11908 Odds = DAG.getNode(ISD::BITCAST, dl, VT, Odds);
11932 SDValue Ahi = DAG.getNode(X86ISD::VSRLI, dl, VT, A, ShAmt);
11933 SDValue Bhi = DAG.getNode(X86ISD::VSRLI, dl, VT, B, ShAmt);
11937 A = DAG.getNode(ISD::BITCAST, dl, MulVT, A);
11938 B = DAG.getNode(ISD::BITCAST, dl, MulVT, B);
11939 Ahi = DAG.getNode(ISD::BITCAST, dl, MulVT, Ahi);
11940 Bhi = DAG.getNode(ISD::BITCAST, dl, MulVT, Bhi);
11942 SDValue AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
11943 SDValue AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
11944 SDValue AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
11946 AloBhi = DAG.getNode(X86ISD::VSHLI, dl, VT, AloBhi, ShAmt);
11947 AhiBlo = DAG.getNode(X86ISD::VSHLI, dl, VT, AhiBlo, ShAmt);
11949 SDValue Res = DAG.getNode(ISD::ADD, dl, VT, AloBlo, AloBhi);
11950 return DAG.getNode(ISD::ADD, dl, VT, Res, AhiBlo);
11982 SDValue ADD = DAG.getNode(ISD::ADD, dl, VT, N0, SRL);
11992 SDValue Zero = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], NumElts);
11993 return DAG.getNode(ISD::SUB, dl, VT, Zero, SRA);
12006 if (isSplatVector(Amt.getNode())) {
12015 return DAG.getNode(X86ISD::VSHLI, dl, VT, R,
12018 return DAG.getNode(X86ISD::VSRLI, dl, VT, R,
12021 return DAG.getNode(X86ISD::VSRAI, dl, VT, R,
12028 SDValue SHL = DAG.getNode(X86ISD::VSHLI, dl, MVT::v8i16, R,
12030 SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
12035 return DAG.getNode(ISD::AND, dl, VT, SHL,
12036 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
12040 SDValue SRL = DAG.getNode(X86ISD::VSRLI, dl, MVT::v8i16, R,
12042 SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
12047 return DAG.getNode(ISD::AND, dl, VT, SRL,
12048 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16));
12054 return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
12058 SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
12061 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 16);
12062 Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
12063 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
12072 SDValue SHL = DAG.getNode(X86ISD::VSHLI, dl, MVT::v16i16, R,
12074 SHL = DAG.getNode(ISD::BITCAST, dl, VT, SHL);
12079 return DAG.getNode(ISD::AND, dl, VT, SHL,
12080 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
12084 SDValue SRL = DAG.getNode(X86ISD::VSRLI, dl, MVT::v16i16, R,
12086 SRL = DAG.getNode(ISD::BITCAST, dl, VT, SRL);
12091 return DAG.getNode(ISD::AND, dl, VT, SRL,
12092 DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32));
12098 return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
12102 SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
12105 SDValue Mask = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &V[0], 32);
12106 Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
12107 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
12150 return DAG.getNode(X86ISD::VSHLI, dl, VT, R,
12153 return DAG.getNode(X86ISD::VSRLI, dl, VT, R,
12156 return DAG.getNode(X86ISD::VSRAI, dl, VT, R,
12219 if (BaseShAmt.getNode() == 0)
12220 BaseShAmt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Amt,
12225 if (BaseShAmt.getNode()) {
12227 BaseShAmt = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BaseShAmt);
12229 BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
12289 return DAG.getNode(X86ISD::VSHL, dl, VT, R, Op.getOperand(1));
12291 return DAG.getNode(X86ISD::VSRL, dl, VT, R, Op.getOperand(1));
12293 return DAG.getNode(X86ISD::VSRA, dl, VT, R, Op.getOperand(1));
12312 if (V.getNode())
12316 if (V.getNode())
12335 Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, VT));
12337 Op = DAG.getNode(ISD::ADD, dl, VT, Op, DAG.getConstant(0x3f800000U, VT));
12338 Op = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, Op);
12339 Op = DAG.getNode(ISD::FP_TO_SINT, dl, VT, Op);
12340 return DAG.getNode(ISD::MUL, dl, VT, Op, R);
12346 Op = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(5, VT));
12347 Op = DAG.getNode(ISD::BITCAST, dl, VT, Op);
12351 SDValue OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
12352 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
12358 SDValue M = DAG.getNode(ISD::AND, dl, VT, R, CM1);
12361 M = DAG.getNode(ISD::BITCAST, dl, VT, M);
12362 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
12365 Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
12366 OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
12367 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
12370 M = DAG.getNode(ISD::AND, dl, VT, R, CM2);
12373 M = DAG.getNode(ISD::BITCAST, dl, VT, M);
12374 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel, M, R);
12377 Op = DAG.getNode(ISD::ADD, dl, VT, Op, Op);
12378 OpVSel = DAG.getNode(ISD::AND, dl, VT, VSelM, Op);
12379 OpVSel = DAG.getNode(X86ISD::PCMPEQ, dl, VT, OpVSel, VSelM);
12382 R = DAG.getNode(ISD::VSELECT, dl, VT, OpVSel,
12383 DAG.getNode(ISD::ADD, dl, VT, R, R), R);
12408 Amt1 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
12410 Amt2 = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT,
12419 V1 = DAG.getNode(Op.getOpcode(), dl, NewVT, V1, Amt1);
12420 V2 = DAG.getNode(Op.getOpcode(), dl, NewVT, V2, Amt2);
12423 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, V1, V2);
12434 SDNode *N = Op.getNode();
12481 SDValue Sum = DAG.getNode(X86ISD::UMUL, DL, VTs, LHS, RHS);
12484 DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
12486 SDValue(Sum.getNode(), 2));
12488 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
12494 SDValue Sum = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
12497 DAG.getNode(X86ISD::SETCC, DL, N->getValueType(1),
12499 SDValue(Sum.getNode(), 1));
12501 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Sum, SetCC);
12541 LHS1 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, Extra);
12542 LHS2 = DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, Extra);
12544 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, LHS1, LHS2);
12557 if (Tmp1.getNode()) {
12561 return DAG.getNode(X86ISD::VSEXT, dl, VT, Tmp1Op0.getOperand(0));
12586 return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
12604 return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
12645 SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
12649 SDValue Tmp = DAG.getNode(ISD::SHL, dl, MVT::i64, rdx,
12652 DAG.getNode(ISD::OR, dl, MVT::i64, rax, Tmp),
12679 SDNode *Node = Op.getNode();
12682 SDValue negOp = DAG.getNode(ISD::SUB, dl, T,
12695 SDNode *Node = Op.getNode();
12720 EVT VT = Op.getNode()->getValueType(0);
12739 return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
12741 return DAG.getNode(Opc, SDLoc(Op), VTs, Op.getOperand(0),
12788 SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
12790 SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
12793 return DAG.getNode(ISD::MERGE_VALUES, dl, Tys, SinVal, CosVal);
12911 SDValue In2L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
12913 SDValue In2H = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
12921 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, OpsF, 2));
12952 if (FIST.getNode() != 0) {
12955 if (StackSlot.getNode() != 0)
12969 SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64,
12973 SDValue VBias = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2f64, Bias, Bias);
12974 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
12975 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, VBias));
12976 Or = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Or);
12977 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
12978 Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
12984 SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
12991 SDValue rd = DAG.getNode(X86ISD::RDTSC_DAG, dl, Tys, &TheChain, 1);
12998 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Ops,
13009 cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
13011 cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
13020 swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
13022 swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
13046 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, T, OpsF, 2));
15549 if (!ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()))
15578 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
15579 SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
15581 DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
15582 SDValue(ResNode.getNode(), 1));
15585 return DAG.getNode(ISD::BITCAST, dl, VT, ResNode);
15695 if (!getTargetShuffleMask(InVec.getNode(), VT.getSimpleVT(), ShuffleMask,
15711 if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
15718 if (!ISD::isNormalLoad(LdNode.getNode()))
15747 Shuffle = DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
15748 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
15758 if (NewOp.getNode())
15764 if (InputVector.getNode()->getOpcode() == llvm::ISD::BITCAST &&
15765 InputVector.getNode()->getOperand(0).getValueType() == MVT::x86mmx &&
15767 return DAG.getNode(X86ISD::MMX_MOVD2W, SDLoc(InputVector),
15769 InputVector.getNode()->getOperand(0));
15781 for (SDNode::use_iterator UI = InputVector.getNode()->use_begin(),
15782 UE = InputVector.getNode()->use_end(); UI != UE; ++UI) {
15832 SDValue ScalarAddr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(),
16071 return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
16097 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
16101 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, LHS.getValueType(), Cond);
16104 return DAG.getNode(ISD::SHL, DL, LHS.getValueType(), Cond,
16111 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
16115 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
16117 return DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
16146 Cond = DAG.getNode(ISD::XOR, DL, Cond.getValueType(), Cond,
16150 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
16154 Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
16159 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
16193 return DAG.getNode(ISD::SELECT, DL, VT, Cond, LHS, RHS);
16209 if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
16212 } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
16216 if (Other.getNode() && Other->getNumOperands() == 2 &&
16226 return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
16231 isSplatVector(CondRHS.getNode()) && isSplatVector(OpRHS.getNode())) {
16234 return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS,
16244 ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
16245 isSplatVector(OpRHS.getNode())) {
16248 return DAG.getNode(X86ISD::SUBUS, DL, VT, OpLHS, OpRHS);
16257 return DAG.getNode(Op, DL, N->getValueType(0), LHS, RHS);
16267 bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
16268 bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
16273 bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
16274 bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
16294 Ret = DAG.getNode(ISD::OR, DL, IntVT, Cond,
16295 DAG.getNode(ISD::BITCAST, DL, IntVT, RHS));
16297 Ret = DAG.getNode(ISD::AND, DL, IntVT, Cond,
16298 DAG.getNode(ISD::BITCAST, DL, IntVT, LHS));
16300 return DAG.getNode(ISD::BITCAST, DL, VT, Ret);
16349 (Cmp.getOpcode() != X86ISD::SUB || Cmp.getNode()->hasAnyUseOfValue(0)))
16492 if (Flags.getNode() &&
16497 return DAG.getNode(X86ISD::CMOV, DL, N->getVTList(),
16518 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
16522 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
16525 Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
16535 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
16539 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
16541 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
16573 Cond = DAG.getNode(X86ISD::SETCC, DL, MVT::i8,
16576 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
16580 Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
16585 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
16628 return DAG.getNode(X86ISD::CMOV, DL, N->getVTList (), Ops,
16681 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
16684 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
16688 NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
16691 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
16720 return DAG.getNode(ISD::AND, SDLoc(N), VT,
16729 if (isSplatVector(N1.getNode())) {
16736 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
16757 if (isSplatVector(Amt.getNode())) {
16781 if (V.getNode()) return V;
16787 if (V.getNode()) return V;
16855 SDValue OnesOrZeroesF = DAG.getNode(NTOperator, DL, MVT::f32, CMP00, CMP01,
16857 SDValue OnesOrZeroesI = DAG.getNode(ISD::BITCAST, DL, MVT::i32,
16859 SDValue ANDed = DAG.getNode(ISD::AND, DL, MVT::i32, OnesOrZeroesI,
16861 SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, ANDed);
16881 N = N->getOperand(0).getNode();
16892 ISD::isBuildVectorAllOnes(V1.getOperand(1).getNode()) &&
16893 ISD::isBuildVectorAllOnes(V2.getNode()))
16940 bool RHSConst = (isSplatVector(N1.getNode()) &&
16953 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, WideVT.getScalarType(),
16956 N1 = DAG.getNode(ISD::BUILD_VECTOR, DL, WideVT, &C[0], C.size());
16962 SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, WideVT, N0, N1);
16971 return DAG.getNode(ISD::AND, DL, VT,
16975 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
16990 if (R.getNode())
17004 return DAG.getNode(X86ISD::BLSI, DL, VT, N1);
17009 return DAG.getNode(X86ISD::BLSI, DL, VT, N0);
17014 return DAG.getNode(X86ISD::BLSR, DL, VT, N1);
17019 return DAG.getNode(X86ISD::BLSR, DL, VT, N0);
17037 //ISD::isBuildVectorAllOnes(N0.getOperand(1).getNode()))
17038 CanFoldXORWithAllOnes(N0.getOperand(1).getNode()))
17039 return DAG.getNode(X86ISD::ANDNP, DL, VT, N0.getOperand(0), N1);
17043 //ISD::isBuildVectorAllOnes(N1.getOperand(1).getNode()))
17044 CanFoldXORWithAllOnes(N1.getOperand(1).getNode()))
17045 return DAG.getNode(X86ISD::ANDNP, DL, VT, N1.getOperand(0), N0);
17058 if (R.getNode())
17084 if (!Y.getNode())
17105 if (isSplatVector(Amt.getNode())) {
17123 ISD::isBuildVectorAllZeros(Y.getOperand(0).getNode()) &&
17127 Mask = DAG.getNode(X86ISD::PSIGN, DL, MaskVT, X, Mask.getOperand(0));
17128 return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
17136 X = DAG.getNode(ISD::BITCAST, DL, BlendVT, X);
17137 Y = DAG.getNode(ISD::BITCAST, DL, BlendVT, Y);
17138 Mask = DAG.getNode(ISD::BITCAST, DL, BlendVT, Mask);
17139 Mask = DAG.getNode(ISD::VSELECT, DL, BlendVT, Mask, Y, X);
17140 return DAG.getNode(ISD::BITCAST, DL, VT, Mask);
17181 if (ShAmt1Op1.getNode()->getOpcode() == ISD::TRUNCATE)
17184 return DAG.getNode(Opc, DL, VT,
17186 DAG.getNode(ISD::TRUNCATE, DL,
17193 return DAG.getNode(Opc, DL, VT,
17195 DAG.getNode(ISD::TRUNCATE, DL,
17225 SDValue Neg = DAG.getNode(X86ISD::SUB, DL, DAG.getVTList(VT, MVT::i32),
17230 SDValue(Neg.getNode(), 1) };
17231 return DAG.getNode(X86ISD::CMOV, DL, DAG.getVTList(VT, MVT::Glue),
17247 if (RV.getNode())
17267 return DAG.getNode(X86ISD::BLSMSK, DL, VT, N1);
17271 return DAG.getNode(X86ISD::BLSMSK, DL, VT, N0);
17306 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
17311 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
17404 Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoadUnitVecVT, ScalarLoad);
17406 Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, LoadUnitVecVT, Res,
17409 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
17412 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
17417 SDValue SlicedVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, Res);
17423 SDValue Sext = DAG.getNode(X86ISD::VSEXT, dl, RegVT, SlicedVec);
17442 Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
17447 Shuff = DAG.getNode(ISD::SRA, dl, RegVT, Shuff,
17463 Shuff = DAG.getNode(ISD::BITCAST, dl, RegVT, Shuff);
17499 SDValue Ptr1 = DAG.getNode(ISD::ADD, dl, Ptr0.getValueType(), Ptr0, Stride);
17508 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
17537 SDValue WideVec = DAG.getNode(ISD::BITCAST, dl, WideVecVT, St->getValue());
17570 SDValue ShuffWide = DAG.getNode(ISD::BITCAST, dl, StoreVecVT, Shuff);
17578 SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
17584 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
17588 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &Chains[0],
17611 SDNode* LdVal = St->getValue().getNode();
17615 SDNode* ChainVal = St->getChain().getNode();
17624 if (ChainVal->getOperand(i).getNode() == LdVal) {
17655 NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
17666 SDValue HiAddr = DAG.getNode(ISD::ADD, LdDL, MVT::i32, LoAddr,
17683 NewChain = DAG.getNode(ISD::TokenFactor, LdDL, MVT::Other, &Ops[0],
17688 HiAddr = DAG.getNode(ISD::ADD, StDL, MVT::i32, LoAddr,
17700 return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
17762 ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(LHS.getNode())->getMask();
17780 ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(RHS.getNode())->getMask();
17794 if (!A.getNode() && !B.getNode())
17812 (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
17813 (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
17826 LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
17827 RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
17842 return DAG.getNode(X86ISD::FHADD, SDLoc(N), VT, LHS, RHS);
17857 return DAG.getNode(X86ISD::FHSUB, SDLoc(N), VT, LHS, RHS);
17894 return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
17951 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
17979 if (!ISD::isNormalLoad(N00.getNode()))
17983 SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
17985 return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
18003 if (R.getNode())
18047 return DAG.getNode(Opcode, dl, VT, A, B, C);
18069 return DAG.getNode(ISD::AND, dl, VT,
18070 DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
18078 if (R.getNode())
18095 SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
18103 SDValue addV = DAG.getNode(ISD::ADD, SDLoc(N),
18115 return DAG.getNode(ISD::AND, DL, MVT::i8,
18116 getNode(X86ISD::SETCC_CARRY, DL, MVT::i8,
18139 SDValue NewSub = DAG.getNode(X86ISD::SUB, SDLoc(EFLAGS),
18140 EFLAGS.getNode()->getVTList(),
18142 SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
18156 if (Flags.getNode()) {
18158 return DAG.getNode(X86ISD::SETCC, DL, N->getVTList(), Cond, Flags);
18178 if (Flags.getNode()) {
18180 return DAG.getNode(X86ISD::BRCOND, DL, N->getVTList(), Chain, Dest, Cond,
18196 SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
18197 return DAG.getNode(ISD::SINT_TO_FP, dl, N->getValueType(0), P);
18203 LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
18206 ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
18232 SDValue Res1 = DAG.getNode(ISD::AND, DL, VT,
18233 DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
18270 SDValue NewCmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32, CmpOp0,
18275 return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::ADC : X86ISD::SBB,
18278 return DAG.getNode(N->getOpcode() == ISD::SUB ? X86ISD::SBB : X86ISD::ADC,
18294 return DAG.getNode(X86ISD::HADD, SDLoc(N), VT, Op0, Op1);
18314 SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
18317 return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
18327 return DAG.getNode(X86ISD::HSUB, SDLoc(N), VT, Op0, Op1);
18344 return DAG.getNode(X86ISD::VZEXT, SDLoc(N), N->getValueType(0),
18457 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
18458 UE = Op.getNode()->use_end(); UI != UE; ++UI) {
18911 if (Result.getNode()) {
