Lines Matching refs:getNode
1317 Value = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Value,
1320 Value = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Value,
1324 Value = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Value);
1331 Value = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Value);
1344 return DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Value);
1346 return DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Value);
1348 return DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Value);
1354 Value = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Value);
1355 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VA.getLocVT(), Value,
1440 FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN,
1458 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, ArgValue,
1501 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
1592 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, SpillSlot,
1611 if (!StackPtr.getNode())
1616 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr,
1627 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOpChains);
1635 Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1638 Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1670 if (Glue.getNode())
1676 return DAG.getNode(SystemZISD::SIBCALL, DL, NodeTys, Ops);
1677 Chain = DAG.getNode(SystemZISD::CALL, DL, NodeTys, Ops);
1678 DAG.addNoMergeSiteInfo(Chain.getNode(), CLI.NoMerge);
1750 return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, Chain);
1778 if (Glue.getNode())
1781 return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, RetOps);
1984 SDValue Intr = DAG.getNode(Opcode, SDLoc(Op), RawVTs, Ops);
1985 SDValue OldChain = SDValue(Op.getNode(), 1);
1986 SDValue NewChain = SDValue(Intr.getNode(), 1);
1988 return Intr.getNode();
2001 SDValue Intr = DAG.getNode(Opcode, SDLoc(Op), Op->getVTList(), Ops);
2002 return Intr.getNode();
2039 auto *ConstOp1 = dyn_cast<ConstantSDNode>(C.Op1.getNode());
2130 auto *Load = dyn_cast<LoadSDNode>(Op.getNode());
2619 if (!C.Op1.getNode()) {
2633 return DAG.getNode(SystemZISD::ICMP, DL, MVT::i32, C.Op0, C.Op1,
2638 return DAG.getNode(SystemZISD::TM, DL, MVT::i32, C.Op0, C.Op1,
2643 return DAG.getNode(C.Opcode, DL, VTs, C.Chain, C.Op0, C.Op1);
2645 return DAG.getNode(C.Opcode, DL, MVT::i32, C.Op0, C.Op1);
2654 Op0 = DAG.getNode(Extend, DL, MVT::i64, Op0);
2655 Op1 = DAG.getNode(Extend, DL, MVT::i64, Op1);
2656 SDValue Mul = DAG.getNode(ISD::MUL, DL, MVT::i64, Op0, Op1);
2657 Hi = DAG.getNode(ISD::SRL, DL, MVT::i64, Mul,
2659 Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Hi);
2660 Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Mul);
2670 SDValue Result = DAG.getNode(Opcode, DL, MVT::Untyped, Op0, Op1);
2685 return DAG.getNode(SystemZISD::SELECT_CCMASK, DL, MVT::i32, Ops);
2767 return DAG.getNode(SystemZISD::STRICT_VEXTEND, DL, VTs, Chain, Op);
2769 return DAG.getNode(SystemZISD::VEXTEND, DL, MVT::v2f64, Op);
2790 SDValue HRes = DAG.getNode(Opcode, DL, VTs, Chain, H0, H1);
2791 SDValue LRes = DAG.getNode(Opcode, DL, VTs, Chain, L0, L1);
2792 SDValue Res = DAG.getNode(SystemZISD::PACK, DL, VT, HRes, LRes);
2796 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
2800 SDValue HRes = DAG.getNode(Opcode, DL, MVT::v2i64, H0, H1);
2801 SDValue LRes = DAG.getNode(Opcode, DL, MVT::v2i64, L0, L1);
2802 return DAG.getNode(SystemZISD::PACK, DL, VT, HRes, LRes);
2806 return DAG.getNode(Opcode, DL, VTs, Chain, CmpOp0, CmpOp1);
2808 return DAG.getNode(Opcode, DL, VT, CmpOp0, CmpOp1);
2840 Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GE);
2842 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
2857 Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GT);
2859 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
2884 Cmp = DAG.getNode(ISD::XOR, DL, VT, Cmp, Mask);
2886 if (Chain && Chain.getNode() != Cmp.getNode()) {
2916 EVT VT = Op.getNode()->getValueType(0);
2940 return DAG.getNode(
2961 Op = DAG.getNode(SystemZISD::IABS, DL, Op.getValueType(), Op);
2963 Op = DAG.getNode(ISD::SUB, DL, Op.getValueType(),
2998 return DAG.getNode(SystemZISD::SELECT_CCMASK, DL, Op.getValueType(), Ops);
3015 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3023 Result = DAG.getNode(SystemZISD::PCREL_OFFSET, DL, PtrVT, Full, Result);
3030 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3034 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3042 Result = DAG.getNode(ISD::ADD, DL, PtrVT, Result,
3092 Chain = DAG.getNode(Opcode, DL, NodeTys, Ops);
3106 TPHi = DAG.getNode(ISD::ANY_EXTEND, DL, PtrVT, TPHi);
3110 TPLo = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TPLo);
3113 SDValue TPHiShifted = DAG.getNode(ISD::SHL, DL, PtrVT, TPHi,
3115 return DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo);
3179 Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Offset, DTPOffset);
3187 Offset = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Offset);
3208 return DAG.getNode(ISD::ADD, DL, PtrVT, TP, Offset);
3219 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3230 return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3247 return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3329 In64 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, In);
3330 In64 = DAG.getNode(ISD::SHL, DL, MVT::i64, In64,
3333 SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::f64, In64);
3341 SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::i64, In64);
3345 SDValue Shift = DAG.getNode(ISD::SRL, DL, MVT::i64, Out64,
3347 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Shift);
3379 FieldAddr = DAG.getNode(ISD::ADD, DL, PtrVT, FieldAddr,
3385 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps);
3437 NeededSpace = DAG.getNode(ISD::ADD, DL, MVT::i64, NeededSpace,
3443 NewSP = DAG.getNode(SystemZISD::PROBED_ALLOCA, DL,
3448 NewSP = DAG.getNode(ISD::SUB, DL, MVT::i64, OldSP, NeededSpace);
3456 SDValue ArgAdjust = DAG.getNode(SystemZISD::ADJDYNALLOC, DL, MVT::i64);
3457 SDValue Result = DAG.getNode(ISD::ADD, DL, MVT::i64, NewSP, ArgAdjust);
3462 DAG.getNode(ISD::ADD, DL, MVT::i64, Result,
3465 DAG.getNode(ISD::AND, DL, MVT::i64, Result,
3480 return DAG.getNode(SystemZISD::ADJDYNALLOC, DL, MVT::i64);
3516 SDValue LH = DAG.getNode(ISD::SRA, DL, VT, LL, C63);
3517 SDValue RH = DAG.getNode(ISD::SRA, DL, VT, RL, C63);
3523 SDValue NegLLTimesRH = DAG.getNode(ISD::AND, DL, VT, LL, RH);
3524 SDValue NegLHTimesRL = DAG.getNode(ISD::AND, DL, VT, LH, RL);
3525 SDValue NegSum = DAG.getNode(ISD::ADD, DL, VT, NegLLTimesRH, NegLHTimesRL);
3526 Ops[1] = DAG.getNode(ISD::SUB, DL, VT, Ops[1], NegSum);
3561 Op0 = DAG.getNode(ISD::SIGN_EXTEND, DL, MVT::i64, Op0);
3563 Op1 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Op1);
3635 SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp);
3643 SDNode *N = Op.getNode();
3676 SDValue Result = DAG.getNode(BaseOp, DL, VTs, LHS, RHS);
3680 SetCC = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, SetCC);
3682 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Result, SetCC);
3701 SDNode *N = Op.getNode();
3737 Carry = DAG.getNode(SystemZISD::GET_CCMASK, DL, MVT::i32, Carry,
3742 SDValue Result = DAG.getNode(BaseOp, DL, VTs, LHS, RHS, Carry);
3746 SetCC = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, SetCC);
3748 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Result, SetCC);
3759 Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Op);
3760 Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::v16i8, Op);
3765 Op = DAG.getNode(ISD::BITCAST, DL, VT, Op);
3767 SDValue Tmp = DAG.getNode(SystemZISD::VSHL_BY_SCALAR, DL, VT, Op, Shift);
3768 Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
3769 Op = DAG.getNode(SystemZISD::VSRL_BY_SCALAR, DL, VT, Op, Shift);
3775 Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
3781 Op = DAG.getNode(SystemZISD::VSUM, DL, MVT::v4i32, Op, Tmp);
3782 Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
3803 Op = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op);
3804 Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::i64, Op);
3805 Op = DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
3810 SDValue Tmp = DAG.getNode(ISD::SHL, DL, VT, Op, DAG.getConstant(I, DL, VT));
3812 Tmp = DAG.getNode(ISD::AND, DL, VT, Tmp,
3814 Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
3819 Op = DAG.getNode(ISD::SRL, DL, VT, Op,
3843 return DAG.getNode(SystemZISD::MEMBARRIER, DL, MVT::Other, Op.getOperand(0));
3849 auto *Node = cast<AtomicSDNode>(Op.getNode());
3858 auto *Node = cast<AtomicSDNode>(Op.getNode());
3875 auto *Node = cast<AtomicSDNode>(Op.getNode());
3899 SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
3904 SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
3906 BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
3910 SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
3919 Src2 = DAG.getNode(ISD::SHL, DL, WideVT, Src2,
3923 Src2 = DAG.getNode(ISD::OR, DL, WideVT, Src2,
3935 SDValue ResultShift = DAG.getNode(ISD::ADD, DL, WideVT, BitShift,
3937 SDValue Result = DAG.getNode(ISD::ROTL, DL, WideVT, AtomicOp, ResultShift);
3948 auto *Node = cast<AtomicSDNode>(Op.getNode());
3965 NegSrc2 = DAG.getNode(ISD::SUB, DL, MemVT, DAG.getConstant(0, DL, MemVT),
3968 if (NegSrc2.getNode())
3983 auto *Node = cast<AtomicSDNode>(Op.getNode());
4015 SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
4020 SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
4022 BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
4026 SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
4114 auto *Node = cast<MemIntrinsicSDNode>(Op.getNode());
4125 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
4126 return DAG.getNode(ISD::SRL, DL, MVT::i32, IPM,
4138 DAG.ReplaceAllUsesOfValueWith(SDValue(Op.getNode(), 0), CC);
4154 return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op), Op->getVTList(),
4164 return DAG.getNode(SystemZISD::PERMUTE_DWORDS, SDLoc(Op), Op.getValueType(),
4168 return DAG.getNode(SystemZISD::PERMUTE, SDLoc(Op), Op.getValueType(),
4174 return DAG.getNode(SystemZISD::UNPACK_HIGH, SDLoc(Op), Op.getValueType(),
4180 return DAG.getNode(SystemZISD::UNPACKL_HIGH, SDLoc(Op), Op.getValueType(),
4186 return DAG.getNode(SystemZISD::UNPACK_LOW, SDLoc(Op), Op.getValueType(),
4192 return DAG.getNode(SystemZISD::UNPACKL_LOW, SDLoc(Op), Op.getValueType(),
4201 return DAG.getNode(SystemZISD::VSUM, SDLoc(Op), Op.getValueType(),
4454 Op0 = DAG.getNode(ISD::BITCAST, DL, InVT, Op0);
4455 Op1 = DAG.getNode(ISD::BITCAST, DL, InVT, Op1);
4459 Op = DAG.getNode(SystemZISD::PERMUTE_DWORDS, DL, InVT, Op0, Op1, Op2);
4463 Op = DAG.getNode(SystemZISD::PACK, DL, OutVT, Op0, Op1);
4465 Op = DAG.getNode(P.Opcode, DL, InVT, Op0, Op1);
4476 return ISD::isBuildVectorAllZeros(N.getNode());
4494 Ops[I] = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Ops[I]);
4499 return DAG.getNode(SystemZISD::SHL_DOUBLE, DL, MVT::v16i8, Ops[OpNo0],
4542 return DAG.getNode(SystemZISD::PERMUTE, DL, MVT::v16i8, Mask, Src,
4545 return DAG.getNode(SystemZISD::PERMUTE, DL, MVT::v16i8, Src, Mask,
4557 return DAG.getNode(SystemZISD::PERMUTE, DL, MVT::v16i8, Ops[0],
4567 SDValue getNode(SelectionDAG &, const SDLoc &);
4607 EVT FromVT = Op.getNode() ? Op.getValueType() : VT;
4619 while (Op.getNode()) {
4661 SDValue GeneralShuffle::getNode(SelectionDAG &DAG, const SDLoc &DL) {
4744 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
4839 SDValue PackedOp = DAG.getNode(ISD::BITCAST, DL, InVT, Op);
4843 return DAG.getNode(SystemZISD::UNPACKL_HIGH, DL, OutVT, PackedOp);
4867 return DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, Value);
4877 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op1);
4880 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op0);
4881 return DAG.getNode(SystemZISD::MERGE_HIGH, DL, VT,
4895 Op0 = Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op1);
4897 Op0 = Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0);
4899 Op0 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0);
4900 Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op1);
4902 return DAG.getNode(SystemZISD::JOIN_DWORDS, DL, MVT::v2i64, Op0, Op1);
4949 if (!Op.getNode()) {
4955 return GS.getNode(DAG, SDLoc(BVN));
4976 if (!Single.getNode())
4998 if (Single.getNode() && (Count > 1 || isVectorElementLoad(Single)))
4999 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Single);
5035 Op01 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Op01);
5036 Op23 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Op23);
5037 SDValue Op = DAG.getNode(SystemZISD::MERGE_HIGH,
5039 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
5063 if (!Constants[I].getNode())
5077 SDNode *Ld = Elems[I].getNode();
5084 Result = DAG.getNode(SystemZISD::REPLICATE, DL, VT, ReplicatedVal);
5094 Result = DAG.getNode(ISD::BITCAST, DL, VT,
5106 Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, Result, Elems[I],
5113 auto *BVN = cast<BuildVectorSDNode>(Op.getNode());
5143 auto *VSN = cast<ShuffleVectorSDNode>(Op.getNode());
5156 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op0.getOperand(Index));
5158 return DAG.getNode(SystemZISD::SPLAT, DL, VT, Op.getOperand(0),
5171 return GS.getNode(DAG, SDLoc(VSN));
5178 return DAG.getNode(ISD::INSERT_VECTOR_ELT, DL,
5208 SDValue Res = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, IntVecVT,
5209 DAG.getNode(ISD::BITCAST, DL, IntVecVT, Op0),
5210 DAG.getNode(ISD::BITCAST, DL, IntVT, Op1), Op2);
5211 return DAG.getNode(ISD::BITCAST, DL, VT, Res);
5235 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, IntVT,
5236 DAG.getNode(ISD::BITCAST, DL, IntVecVT, Op0), Op1);
5237 return DAG.getNode(ISD::BITCAST, DL, VT, Res);
5252 DAG.getNode(SystemZISD::UNPACK_HIGH, SDLoc(PackedOp), OutVT, PackedOp);
5281 return DAG.getNode(ISD::BITCAST, DL, OutVT, Shuf);
5305 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
5313 SDValue Shift = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Splat);
5314 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
5330 SDValue Shift = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32,
5332 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
5468 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, In,
5470 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, In,
5483 return DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i128, Lo, Hi);
5752 Op = DAG.getNode(ISD::BITCAST, DL, VT, Op);
5753 DCI.AddToWorklist(Op.getNode());
5756 Op = DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
5758 DCI.AddToWorklist(Op.getNode());
5759 Op = DAG.getNode(ISD::BITCAST, DL, ResVT, Op);
5792 Op = DAG.getNode(ISD::BITCAST, DL, VecVT, Op);
5793 DCI.AddToWorklist(Op.getNode());
5795 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ResVT, Op,
5852 SDValue NewSelect = DAG.getNode(SystemZISD::SELECT_CCMASK, DL, VT, Ops);
5856 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), NewSelect);
5857 DCI.CombineTo(N0.getNode(), TruncSelect);
5881 return DAG.getNode(ISD::SELECT_CC, DL, VT, Ops);
5903 SDValue Ext = DAG.getNode(ISD::ANY_EXTEND, SDLoc(Inner), VT,
5905 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(Inner), VT, Ext,
5908 return DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl,
5924 if (ISD::isBuildVectorAllZeros(Op0.getNode())) {
5939 Op1 = DAG.getNode(ISD::BITCAST, SDLoc(N), InVT, Op1);
5940 DCI.AddToWorklist(Op1.getNode());
5942 SDValue Op = DAG.getNode(Opcode, SDLoc(N), OutVT, Op1);
5943 DCI.AddToWorklist(Op.getNode());
5944 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
5978 SDValue Extract0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, LdVT,
5984 Ops.push_back((Op.getNode() == N && Op.getResNo() == 0) ? Extract0 : Op);
6028 DCI.AddToWorklist(Value.getNode());
6039 Op1.getNode()->hasOneUse() &&
6045 BSwapOp = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), MVT::i32, BSwapOp);
6058 Op1.getNode()->hasOneUse() &&
6060 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op1.getNode());
6080 if (ISD::isNON_EXTLoad(N->getOperand(0).getNode()) &&
6105 DCI.CombineTo(Load.getNode(), ESLoad, ESLoad.getValue(1));
6135 Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), EltVT,
6137 DCI.AddToWorklist(Op.getNode());
6138 Op = DAG.getNode(ISD::BSWAP, SDLoc(N), EltVT, Op);
6140 DCI.AddToWorklist(Op.getNode());
6141 Op = DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Op);
6161 return DAG.getNode(SystemZISD::REPLICATE, SDLoc(N), N->getValueType(0),
6202 if (U != Op0.getNode() &&
6214 Chain = MergeInputChains(N, OtherRound.getNode());
6217 VRound = DAG.getNode(SystemZISD::STRICT_VROUND, SDLoc(N),
6221 VRound = DAG.getNode(SystemZISD::VROUND, SDLoc(N),
6223 DCI.AddToWorklist(VRound.getNode());
6225 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(U), MVT::f32,
6227 DCI.AddToWorklist(Extract1.getNode());
6232 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op0), MVT::f32,
6235 return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op0),
6268 if (U != Op0.getNode() &&
6280 Chain = MergeInputChains(N, OtherExtend.getNode());
6283 VExtend = DAG.getNode(SystemZISD::STRICT_VEXTEND, SDLoc(N),
6287 VExtend = DAG.getNode(SystemZISD::VEXTEND, SDLoc(N),
6289 DCI.AddToWorklist(VExtend.getNode());
6291 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(U), MVT::f64,
6293 DCI.AddToWorklist(Extract1.getNode());
6298 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op0), MVT::f64,
6301 return DAG.getNode(ISD::MERGE_VALUES, SDLoc(Op0),
6331 SDValue ExtOp = DAG.getNode(ExtOpcode, SDLoc(N), ExtVT, Op);
6332 return DAG.getNode(Opcode, SDLoc(N), OutVT, ExtOp);
6341 if (ISD::isNON_EXTLoad(N->getOperand(0).getNode()) &&
6363 ResVal = DAG.getNode(ISD::TRUNCATE, SDLoc(N), MVT::i16, BSLoad);
6371 DCI.CombineTo(Load.getNode(), ResVal, BSLoad.getValue(1));
6397 ISD::isNON_EXTLoad(Elt.getNode()) && Elt.hasOneUse())) {
6401 Vec = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Vec);
6402 DCI.AddToWorklist(Vec.getNode());
6405 Elt = DAG.getNode(ISD::BITCAST, SDLoc(N), EltVT, Elt);
6406 DCI.AddToWorklist(Elt.getNode());
6408 Vec = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Vec);
6409 DCI.AddToWorklist(Vec.getNode());
6410 Elt = DAG.getNode(ISD::BSWAP, SDLoc(N), EltVT, Elt);
6411 DCI.AddToWorklist(Elt.getNode());
6412 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N), VecVT,
6429 Op0 = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Op0);
6430 DCI.AddToWorklist(Op0.getNode());
6433 Op1 = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Op1);
6434 DCI.AddToWorklist(Op1.getNode());
6436 Op0 = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Op0);
6437 DCI.AddToWorklist(Op0.getNode());
6438 Op1 = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Op1);
6439 DCI.AddToWorklist(Op1.getNode());
6457 auto *ICmp = CCReg.getNode();
6460 auto *CompareLHS = ICmp->getOperand(0).getNode();
6506 auto *SHL = CompareLHS->getOperand(0).getNode();
6512 auto *IPM = SHL->getOperand(0).getNode();
6550 return DAG.getNode(SystemZISD::BR_CCMASK, SDLoc(N), N->getValueType(0),
6573 return DAG.getNode(SystemZISD::SELECT_CCMASK, SDLoc(N), N->getValueType(0),