Lines Matching refs:getNode
2040 Val = DAG.getNode(ISD::BITCAST, dl, MVT::getIntegerVT(LocVT.getSizeInBits()),
2043 Val = DAG.getNode(ARMISD::VMOVhr, dl, ValVT, Val);
2045 Val = DAG.getNode(ISD::TRUNCATE, dl,
2047 Val = DAG.getNode(ISD::BITCAST, dl, ValVT, Val);
2056 Val = DAG.getNode(ARMISD::VMOVrh, dl,
2059 Val = DAG.getNode(ISD::BITCAST, dl,
2061 Val = DAG.getNode(ISD::ZERO_EXTEND, dl,
2064 return DAG.getNode(ISD::BITCAST, dl, LocVT, Val);
2108 Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
2111 SDValue Vec = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
2112 Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
2125 Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
2126 Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Vec, Val,
2140 Val = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), Val);
2165 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
2179 SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
2188 if (!StackPtr.getNode())
2306 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
2309 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
2312 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
2315 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
2334 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::getIntegerVT(LocBits), Arg);
2335 Arg = DAG.getNode(ISD::AND, dl, MVT::getIntegerVT(LocBits), Arg, Mask);
2336 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
2342 SDValue Op0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2344 SDValue Op1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2395 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
2414 SDValue Dst = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, StkPtrOff);
2416 SDValue Src = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, SrcOffset);
2424 MemOpChains.push_back(DAG.getNode(ARMISD::COPY_STRUCT_BYVAL, dl, VTs,
2436 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
2478 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2492 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2507 Callee = DAG.getNode(
2528 DAG.getNode(ARMISD::Wrapper, dl, PtrVt, Callee),
2544 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2549 Callee = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVt, Callee, PICLabel);
2626 if (InFlag.getNode())
2632 SDValue Ret = DAG.getNode(ARMISD::TC_RETURN, dl, NodeTys, Ops);
2633 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
2638 Chain = DAG.getNode(CallOpc, dl, NodeTys, Ops);
2639 DAG.addNoMergeSiteInfo(Chain.getNode(), CLI.NoMerge);
2641 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
2773 (!isa<GlobalAddressSDNode>(Callee.getNode()) || isIndirect))
2923 return DAG.getNode(ARMISD::INTRET_FLAG, DL, MVT::Other, RetOps);
3000 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
3014 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::getIntegerVT(LocBits), Arg);
3015 Arg = DAG.getNode(ISD::AND, dl, MVT::getIntegerVT(LocBits), Arg, Mask);
3016 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
3024 SDValue Half = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
3026 SDValue HalfGPRs = DAG.getNode(ARMISD::VMOVRRD, dl,
3043 Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
3048 SDValue fmrrd = DAG.getNode(ARMISD::VMOVRRD, dl,
3082 if (Flag.getNode())
3100 return DAG.getNode(RetNode, dl, MVT::Other, RetOps);
3133 if (Copies.count(UseChain.getNode()))
3198 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, WriteValue,
3200 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, WriteValue,
3203 return DAG.getNode(ISD::WRITE_REGISTER, DL, MVT::Other, Ops);
3246 return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Res);
3273 CPAddr = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, CPAddr);
3280 return DAG.getNode(ARMISD::PIC_ADD, DL, PtrVT, Result, PICLabel);
3346 DAG.getNode(ARMISD::CALL, DL, DAG.getVTList(MVT::Other, MVT::Glue),
3369 SDValue CurrentTEB = DAG.getNode(ISD::INTRINSIC_W_CHAIN, DL,
3378 DAG.getNode(ISD::ADD, DL, PtrVT, TEB, DAG.getIntPtrConstant(0x2c, DL));
3387 TLSIndex = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, TLSIndex);
3390 SDValue Slot = DAG.getNode(ISD::SHL, DL, PtrVT, TLSIndex,
3393 DAG.getNode(ISD::ADD, DL, PtrVT, TLSArray, Slot),
3401 DAG.getNode(ARMISD::Wrapper, DL, MVT::i32,
3405 return DAG.getNode(ISD::ADD, DL, PtrVT, TLS, Offset);
3422 Argument = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Argument);
3429 Argument = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Argument, PICLabel);
3460 SDValue ThreadPointer = DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
3473 Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
3480 Offset = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Offset, PICLabel);
3491 Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
3499 return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
3643 return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3685 SDValue Result = DAG.getNode(ARMISD::WrapperPIC, dl, PtrVT, G);
3694 SDValue Result = DAG.getNode(ARMISD::WrapperPIC, dl, PtrVT, G);
3702 RelAddr = DAG.getNode(ARMISD::Wrapper, dl, PtrVT, G);
3707 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3713 SDValue Result = DAG.getNode(ISD::ADD, dl, PtrVT, SB, RelAddr);
3723 return DAG.getNode(ARMISD::Wrapper, dl, PtrVT,
3727 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3751 SDValue Result = DAG.getNode(Wrapper, dl, PtrVT, G);
3782 Result = DAG.getNode(ARMISD::Wrapper, DL, PtrVT,
3795 return DAG.getNode(ARMISD::EH_SJLJ_SETJMP, dl,
3803 return DAG.getNode(ARMISD::EH_SJLJ_LONGJMP, dl, MVT::Other, Op.getOperand(0),
3810 return DAG.getNode(ARMISD::EH_SJLJ_SETUP_DISPATCH, dl, MVT::Other,
3865 return DAG.getNode(ARMISD::THREAD_POINTER, dl, PtrVT);
3871 DAG.getNode(ISD::SRA, dl, VTy, Operand, DAG.getConstant(31, dl, VTy));
3872 SDValue XOR = DAG.getNode(ISD::XOR, dl, VTy, SRA, Operand);
3874 DAG.getNode(ISD::SHL, dl, VTy, XOR, DAG.getConstant(1, dl, VTy));
3876 DAG.getNode(ISD::OR, dl, VTy, SHL, DAG.getConstant(1, dl, VTy));
3877 SDValue Result = DAG.getNode(ISD::CTLZ, dl, VTy, OR);
3886 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VTy, Operand,
3888 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VTy, Operand,
3893 SDValue SRAHi = DAG.getNode(ISD::SRA, dl, VTy, Hi, Constant31);
3894 SDValue XORHi = DAG.getNode(ISD::XOR, dl, VTy, SRAHi, Hi);
3895 SDValue SHLHi = DAG.getNode(ISD::SHL, dl, VTy, XORHi, Constant1);
3896 SDValue ORHi = DAG.getNode(ISD::OR, dl, VTy, SHLHi, Constant1);
3897 SDValue CLSHi = DAG.getNode(ISD::CTLZ, dl, VTy, ORHi);
3904 SDValue CLZAdjustedLo = DAG.getNode(ISD::CTLZ, dl, VTy, AdjustedLo);
3907 DAG.getNode(ISD::ADD, dl, VTy, CLZAdjustedLo, Constant31), CLSHi);
3922 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3929 Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
3934 return DAG.getNode(ISD::ABS, SDLoc(Op), Op.getValueType(),
3940 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3947 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3956 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3965 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3970 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3974 return DAG.getNode(ARMISD::VTBL1, SDLoc(Op), Op.getValueType(),
3977 return DAG.getNode(ARMISD::VTBL2, SDLoc(Op), Op.getValueType(),
3981 return DAG.getNode(ARMISD::PREDICATE_CAST, SDLoc(Op), Op.getValueType(),
3984 return DAG.getNode(ARMISD::VECTOR_REG_CAST, SDLoc(Op), Op.getValueType(),
3987 return DAG.getNode(ARMISD::LSLL, SDLoc(Op), Op->getVTList(),
3990 return DAG.getNode(ARMISD::ASRL, SDLoc(Op), Op->getVTList(),
4009 return DAG.getNode(ARMISD::MEMBARRIER_MCR, dl, MVT::Other, Op.getOperand(0),
4027 return DAG.getNode(ISD::INTRINSIC_VOID, dl, MVT::Other, Op.getOperand(0),
4054 return DAG.getNode(ARMISD::PRELOAD, dl, MVT::Other, Op.getOperand(0),
4107 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, ArgValue, ArgValue2);
4163 FIN = DAG.getNode(ISD::ADD, dl, PtrVT, FIN, DAG.getConstant(4, dl, PtrVT));
4167 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOps);
4201 Val = DAG.getNode(ISD::BITCAST, DL, MVT::getIntegerVT(ValueBits), Val);
4202 Val = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::getIntegerVT(PartBits), Val);
4203 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
4220 Val = DAG.getNode(ISD::BITCAST, DL, MVT::getIntegerVT(PartBits), Val);
4221 Val = DAG.getNode(ISD::TRUNCATE, DL, MVT::getIntegerVT(ValueBits), Val);
4222 Val = DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
4316 ArgValue = DAG.getNode(ISD::UNDEF, dl, MVT::v2f64);
4317 ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, ArgValue,
4319 ArgValue = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, ArgValue,
4360 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
4363 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
4365 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
4368 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
4370 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
4440 else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
4465 if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
4535 auto *RHSC = cast<ConstantSDNode>(RHS.getNode());
4541 LHS = DAG.getNode(ISD::SHL, dl, MVT::i32, LHS.getOperand(0), ShiftAmt);
4560 SDValue Shift = DAG.getNode(ARMISD::LSLS, dl,
4599 return DAG.getNode(CompareType, dl, MVT::Glue, LHS, RHS);
4609 Cmp = DAG.getNode(Signaling ? ARMISD::CMPFPE : ARMISD::CMPFP,
4612 Cmp = DAG.getNode(Signaling ? ARMISD::CMPFPEw0 : ARMISD::CMPFPw0,
4614 return DAG.getNode(ARMISD::FMSTAT, dl, MVT::Glue, Cmp);
4624 return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
4630 Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
4633 Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0));
4635 return DAG.getNode(ARMISD::FMSTAT, DL, MVT::Glue, Cmp);
4662 Value = DAG.getNode(ISD::ADD, dl, Op.getValueType(), LHS, RHS);
4663 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value, LHS);
4669 Value = DAG.getNode(ARMISD::ADDC, dl,
4672 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value, LHS);
4676 Value = DAG.getNode(ISD::SUB, dl, Op.getValueType(), LHS, RHS);
4677 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, LHS, RHS);
4681 Value = DAG.getNode(ISD::SUB, dl, Op.getValueType(), LHS, RHS);
4682 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, LHS, RHS);
4687 Value = DAG.getNode(ISD::UMUL_LOHI, dl,
4690 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value.getValue(1),
4698 Value = DAG.getNode(ISD::SMUL_LOHI, dl,
4701 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value.getValue(1),
4702 DAG.getNode(ISD::SRA, dl, Op.getValueType(),
4728 SDValue Overflow = DAG.getNode(ARMISD::CMOV, dl, VT, TVal, FVal,
4732 return DAG.getNode(ISD::MERGE_VALUES, dl, VTs, Value, Overflow);
4742 SDValue Carry = DAG.getNode(ARMISD::SUBC, DL,
4754 return DAG.getNode(ARMISD::ADDE, DL, DAG.getVTList(VT, MVT::i32),
4777 Value = DAG.getNode(ARMISD::ADDC, dl, VTs, LHS, RHS);
4782 Value = DAG.getNode(ARMISD::SUBC, dl, VTs, LHS, RHS);
4787 Overflow = DAG.getNode(ISD::SUB, dl, MVT::i32,
4793 return DAG.getNode(ISD::MERGE_VALUES, dl, VTs, Value, Overflow);
4819 DAG.getNode(NewOpcode, dl, MVT::i32,
4822 return DAG.getNode(ISD::TRUNCATE, dl, VT, Add);
4873 if (True.getNode() && False.getNode()) {
4886 Cond = DAG.getNode(ISD::AND, dl, Cond.getValueType(), Cond,
4948 FalseVal = DAG.getNode(ARMISD::VMOVRRD, dl,
4950 TrueVal = DAG.getNode(ARMISD::VMOVRRD, dl,
4958 SDValue Low = DAG.getNode(ARMISD::CMOV, dl, MVT::i32, FalseLow, TrueLow,
4960 SDValue High = DAG.getNode(ARMISD::CMOV, dl, MVT::i32, FalseHigh, TrueHigh,
4963 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Low, High);
4965 return DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal, ARMcc, CCR,
5174 return DAG.getNode(ARMISD::USAT, dl, VT, SatValue,
5177 return DAG.getNode(ARMISD::SSAT, dl, VT, SatValue,
5190 SDValue ShiftV = DAG.getNode(ISD::SRA, dl, VT, SatValue,
5193 SDValue NotShiftV = DAG.getNode(ISD::XOR, dl, VT, ShiftV,
5195 return DAG.getNode(ISD::AND, dl, VT, SatValue, NotShiftV);
5197 return DAG.getNode(ISD::OR, dl, VT, SatValue, ShiftV);
5254 return DAG.getNode(Opcode, dl, VT, TrueVal, FalseVal, ARMcc, Cmp);
5264 if (!RHS.getNode()) {
5343 SDNode *N = Op.getNode();
5392 SDValue NewPtr = DAG.getNode(ISD::ADD, dl,
5430 LHS = DAG.getNode(ISD::AND, dl, MVT::i32,
5432 RHS = DAG.getNode(ISD::AND, dl, MVT::i32,
5436 return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
5444 LHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, LHS2, Mask);
5445 RHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, RHS2, Mask);
5450 return DAG.getNode(ARMISD::BCC_i64, dl, VTList, Ops);
5486 return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other, Chain, Dest, ARMcc, CCR,
5507 if (!RHS.getNode()) {
5540 return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other, Chain, Dest, ARMcc, CCR,
5548 return DAG.getNode(ARMISD::BRCOND, dl, MVT::Other,
5567 SDValue Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops);
5571 Res = DAG.getNode(ARMISD::BRCOND, dl, VTList, Ops);
5585 Table = DAG.getNode(ARMISD::WrapperJT, dl, MVT::i32, JTI);
5586 Index = DAG.getNode(ISD::MUL, dl, PTy, Index, DAG.getConstant(4, dl, PTy));
5587 SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Table, Index);
5593 return DAG.getNode(ARMISD::BR2_JT, dl, MVT::Other, Chain,
5601 Addr = DAG.getNode(ISD::ADD, dl, PTy, Table, Addr);
5602 return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI);
5608 return DAG.getNode(ARMISD::BR_JT, dl, MVT::Other, Chain, Addr, JTI);
5619 return DAG.UnrollVectorOp(Op.getNode());
5637 return DAG.UnrollVectorOp(Op.getNode());
5639 Op = DAG.getNode(Op.getOpcode(), dl, NewTy, Op.getOperand(0));
5640 return DAG.getNode(ISD::TRUNCATE, dl, VT, Op);
5673 DAG.getNode(Op.getOpcode() == ISD::STRICT_FP_TO_SINT ? ISD::FP_TO_SINT
5689 return DAG.UnrollVectorOp(Op.getNode());
5707 return DAG.UnrollVectorOp(Op.getNode());
5723 Op = DAG.getNode(CastOpc, dl, DestVecType, Op.getOperand(0));
5724 return DAG.getNode(Opc, dl, VT, Op);
5761 SDValue Mask = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v2i32,
5765 Mask = DAG.getNode(ARMISD::VSHLIMM, dl, OpVT,
5766 DAG.getNode(ISD::BITCAST, dl, OpVT, Mask),
5769 Tmp0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp0);
5771 Tmp1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp1);
5773 Tmp1 = DAG.getNode(ARMISD::VSHLIMM, dl, OpVT,
5774 DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1),
5777 Tmp1 = DAG.getNode(ARMISD::VSHRuIMM, dl, MVT::v1i64,
5778 DAG.getNode(ISD::BITCAST, dl, MVT::v1i64, Tmp1),
5780 Tmp0 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp0);
5781 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1);
5785 AllOnes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v8i8, AllOnes);
5786 SDValue MaskNot = DAG.getNode(ISD::XOR, dl, OpVT, Mask,
5787 DAG.getNode(ISD::BITCAST, dl, OpVT, AllOnes));
5789 SDValue Res = DAG.getNode(ISD::OR, dl, OpVT,
5790 DAG.getNode(ISD::AND, dl, OpVT, Tmp1, Mask),
5791 DAG.getNode(ISD::AND, dl, OpVT, Tmp0, MaskNot));
5793 Res = DAG.getNode(ISD::BITCAST, dl, MVT::v2f32, Res);
5794 Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, Res,
5797 Res = DAG.getNode(ISD::BITCAST, dl, MVT::f64, Res);
5805 Tmp1 = DAG.getNode(ARMISD::VMOVRRD, dl, DAG.getVTList(MVT::i32, MVT::i32),
5807 Tmp1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Tmp1);
5812 Tmp1 = DAG.getNode(ISD::AND, dl, MVT::i32, Tmp1, Mask1);
5814 Tmp0 = DAG.getNode(ISD::AND, dl, MVT::i32,
5815 DAG.getNode(ISD::BITCAST, dl, MVT::i32, Tmp0), Mask2);
5816 return DAG.getNode(ISD::BITCAST, dl, MVT::f32,
5817 DAG.getNode(ISD::OR, dl, MVT::i32, Tmp0, Tmp1));
5821 Tmp0 = DAG.getNode(ARMISD::VMOVRRD, dl, DAG.getVTList(MVT::i32, MVT::i32),
5824 SDValue Hi = DAG.getNode(ISD::AND, dl, MVT::i32, Tmp0.getValue(1), Mask2);
5825 Hi = DAG.getNode(ISD::OR, dl, MVT::i32, Hi, Tmp1);
5826 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
5844 DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
5894 SDValue Read = DAG.getNode(ISD::READ_REGISTER, DL,
5899 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Read.getValue(0),
5949 SDValue BitCast = DAG.getNode(ISD::BITCAST, dl, VecVT, ExtractSrc);
5950 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DstVT, BitCast,
5973 DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), MVT::i32, Op));
5977 return DAG.getNode(
5991 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
5993 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
5995 return DAG.getNode(ISD::BITCAST, dl, DstVT,
5996 DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi));
6004 Cvt = DAG.getNode(ARMISD::VMOVRRD, dl,
6006 DAG.getNode(ARMISD::VREV64, dl, SrcVT, Op));
6008 Cvt = DAG.getNode(ARMISD::VMOVRRD, dl,
6011 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Cvt, Cvt.getValue(1));
6028 SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, EncodedVal);
6029 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
6049 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
6051 SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, ShAmt);
6052 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
6054 SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, RevShAmt);
6055 SDValue LoSmallShift = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
6056 SDValue LoBigShift = DAG.getNode(Opc, dl, VT, ShOpHi, ExtraShAmt);
6059 SDValue Lo = DAG.getNode(ARMISD::CMOV, dl, VT, LoSmallShift, LoBigShift,
6062 SDValue HiSmallShift = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
6064 ? DAG.getNode(Opc, dl, VT, ShOpHi,
6069 SDValue Hi = DAG.getNode(ARMISD::CMOV, dl, VT, HiSmallShift, HiBigShift,
6091 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
6093 SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
6094 SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
6095 SDValue HiSmallShift = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
6097 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
6099 SDValue HiBigShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
6102 SDValue Hi = DAG.getNode(ARMISD::CMOV, dl, VT, HiSmallShift, HiBigShift,
6107 SDValue LoSmallShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
6108 SDValue Lo = DAG.getNode(ARMISD::CMOV, dl, VT, LoSmallShift,
6127 DAG.getNode(ISD::INTRINSIC_W_CHAIN, dl, {MVT::i32, MVT::Other}, Ops);
6129 SDValue FltRounds = DAG.getNode(ISD::ADD, dl, MVT::i32, FPSCR,
6131 SDValue RMODE = DAG.getNode(ISD::SRL, dl, MVT::i32, FltRounds,
6133 SDValue And = DAG.getNode(ISD::AND, dl, MVT::i32, RMODE,
6146 SDValue NX = DAG.getNode(ISD::SUB, dl, VT, getZeroVector(VT, DAG, dl), X);
6147 SDValue LSB = DAG.getNode(ISD::AND, dl, VT, X, NX);
6153 SDValue One = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
6155 SDValue Bits = DAG.getNode(ISD::SUB, dl, VT, LSB, One);
6156 return DAG.getNode(ISD::CTPOP, dl, VT, Bits);
6164 DAG.getNode(ARMISD::VMOVIMM, dl, VT,
6166 SDValue CTLZ = DAG.getNode(ISD::CTLZ, dl, VT, LSB);
6167 return DAG.getNode(ISD::SUB, dl, VT, WidthMinus1, CTLZ);
6176 SDValue FF = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
6178 Bits = DAG.getNode(ISD::ADD, dl, VT, LSB, FF);
6180 SDValue One = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
6182 Bits = DAG.getNode(ISD::SUB, dl, VT, LSB, One);
6184 return DAG.getNode(ISD::CTPOP, dl, VT, Bits);
6190 SDValue rbit = DAG.getNode(ISD::BITREVERSE, dl, VT, N->getOperand(0));
6191 return DAG.getNode(ISD::CTLZ, dl, VT, rbit);
6207 Res = DAG.getNode(ISD::CTPOP, DL, VT8Bit, Res);
6221 Res = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, WidenVT, Ops);
6234 BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
6297 return DAG.getNode(ARMISD::VSHLIMM, dl, VT, N->getOperand(0),
6299 return DAG.getNode(ARMISD::VSHLu, dl, VT, N->getOperand(0),
6309 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0),
6316 SDValue NegatedCount = DAG.getNode(
6320 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0), NegatedCount);
6356 ShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
6365 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6368 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6372 Lo = DAG.getNode(ShPartsOpc, dl, DAG.getVTList(MVT::i32, MVT::i32), Lo, Hi,
6375 Hi = SDValue(Lo.getNode(), 1);
6376 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
6388 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6390 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6396 Hi = DAG.getNode(Opc, dl, DAG.getVTList(MVT::i32, MVT::Glue), Hi);
6399 Lo = DAG.getNode(ARMISD::RRX, dl, MVT::i32, Lo, Hi.getValue(1));
6402 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
6442 SDValue CastOp0 = DAG.getNode(ISD::BITCAST, dl, SplitVT, Op0);
6443 SDValue CastOp1 = DAG.getNode(ISD::BITCAST, dl, SplitVT, Op1);
6444 SDValue Cmp = DAG.getNode(ISD::SETCC, dl, SplitVT, CastOp0, CastOp1,
6446 SDValue Reversed = DAG.getNode(ARMISD::VREV64, dl, SplitVT, Cmp);
6447 SDValue Merged = DAG.getNode(ISD::AND, dl, SplitVT, Cmp, Reversed);
6448 Merged = DAG.getNode(ISD::BITCAST, dl, CmpVT, Merged);
6486 SDValue TmpOp0 = DAG.getNode(ARMISD::VCMP, dl, CmpVT, Op1, Op0,
6488 SDValue TmpOp1 = DAG.getNode(ARMISD::VCMP, dl, CmpVT, Op0, Op1,
6490 SDValue Result = DAG.getNode(ISD::OR, dl, CmpVT, TmpOp0, TmpOp1);
6498 SDValue TmpOp0 = DAG.getNode(ARMISD::VCMP, dl, CmpVT, Op1, Op0,
6500 SDValue TmpOp1 = DAG.getNode(ARMISD::VCMP, dl, CmpVT, Op0, Op1,
6502 SDValue Result = DAG.getNode(ISD::OR, dl, CmpVT, TmpOp0, TmpOp1);
6532 if (ISD::isBuildVectorAllZeros(Op1.getNode()))
6534 else if (ISD::isBuildVectorAllZeros(Op0.getNode()))
6538 if (AndOp.getNode() && AndOp.getOpcode() == ISD::BITCAST)
6541 if (AndOp.getNode() && AndOp.getOpcode() == ISD::AND) {
6542 Op0 = DAG.getNode(ISD::BITCAST, dl, CmpVT, AndOp.getOperand(0));
6543 Op1 = DAG.getNode(ISD::BITCAST, dl, CmpVT, AndOp.getOperand(1));
6544 SDValue Result = DAG.getNode(ARMISD::VTST, dl, CmpVT, Op0, Op1);
6558 if (ISD::isBuildVectorAllZeros(Op1.getNode()))
6560 else if (ISD::isBuildVectorAllZeros(Op0.getNode())) {
6569 if (SingleOp.getNode()) {
6570 Result = DAG.getNode(ARMISD::VCMPZ, dl, CmpVT, SingleOp,
6573 Result = DAG.getNode(ARMISD::VCMP, dl, CmpVT, Op0, Op1,
6596 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
6602 SDValue Cmp = DAG.getNode(ARMISD::SUBE, DL, VTs, LHS, RHS, Carry);
6611 return DAG.getNode(ARMISD::CMOV, DL, Op.getValueType(), FVal, TVal, ARMcc,
6791 return DAG.getNode(ARMISD::VMOVDRR, DL, MVT::f64, Lo, Hi);
6794 return DAG.getNode(ARMISD::VMOVSR, DL, VT,
6821 SDValue VecConstant = DAG.getNode(ARMISD::VMOVFPIMM, DL, MVT::v2f32,
6823 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecConstant,
6846 SDValue VecConstant = DAG.getNode(ARMISD::VMOVIMM, DL, VMovVT,
6849 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, VecConstant);
6852 SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
6854 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecFConstant,
6863 SDValue VecConstant = DAG.getNode(ARMISD::VMVNIMM, DL, VMovVT, NewVal);
6866 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, VecConstant);
6869 SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
6871 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecFConstant,
7316 SDValue N1 = DAG.getNode(ARMISD::VCVTN, dl, VT, DAG.getUNDEF(VT), Op0,
7318 return DAG.getNode(ARMISD::VCVTN, dl, VT, N1, Op1,
7362 return DAG.getNode(ARMISD::VCVTL, dl, VT, Op0,
7416 SDValue Ext = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::i32, FirstOp,
7418 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, Op.getValueType(), Ext);
7433 SDValue Base = DAG.getNode(ARMISD::PREDICATE_CAST, dl, VT,
7439 Base = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Base, V,
7450 BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
7472 if (Val.getNode()) {
7473 SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, Val);
7474 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
7482 if (Val.getNode()) {
7483 SDValue Vmov = DAG.getNode(ARMISD::VMVNIMM, dl, VmovVT, Val);
7484 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
7492 return DAG.getNode(ARMISD::VMOVFPIMM, dl, VT, Val);
7535 if (!Value.getNode() && !ValueCounts.empty())
7543 if (isOnlyLowElement && !ISD::isNormalLoad(Value.getNode()))
7544 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value);
7569 N = DAG.getNode(ARMISD::VDUPLANE, dl, VT,
7570 DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, DAG.getUNDEF(VT),
7574 N = DAG.getNode(ARMISD::VDUPLANE, dl, VT,
7577 N = DAG.getNode(ARMISD::VDUP, dl, VT, Value);
7589 N = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Ops);
7600 Ops.push_back(DAG.getNode(ISD::BITCAST, dl, IVT,
7605 if (Val.getNode())
7606 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
7610 if (isConstant && Val.getNode())
7611 return DAG.getNode(ARMISD::VDUP, dl, VT, Val);
7650 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lower, Upper);
7663 Ops.push_back(DAG.getNode(ISD::BITCAST, dl, EltVT, Op.getOperand(i)));
7664 SDValue Val = DAG.getNode(ARMISD::BUILD_VECTOR, dl, VecVT, Ops);
7665 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
7681 Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Vec, V, LaneIdx);
7786 DAG.getNode(ISD::CONCAT_VECTORS, dl, DestVT, Src.ShuffleVec,
7802 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7808 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7813 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7816 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7819 Src.ShuffleVec = DAG.getNode(ARMISD::VEXT, dl, DestVT, VEXTSrc1,
7834 Src.ShuffleVec = DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, ShuffleVT, Src.ShuffleVec);
7886 return DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, VT, Shuffle);
7998 return DAG.getNode(ARMISD::VREV64, dl, VT, OpLHS);
8001 return DAG.getNode(ARMISD::VREV32, dl, VT, OpLHS);
8004 return DAG.getNode(ARMISD::VREV16, dl, VT, OpLHS);
8009 return DAG.getNode(ARMISD::VDUPLANE, dl, VT,
8014 return DAG.getNode(ARMISD::VEXT, dl, VT,
8019 return DAG.getNode(ARMISD::VUZP, dl, DAG.getVTList(VT, VT),
8023 return DAG.getNode(ARMISD::VZIP, dl, DAG.getVTList(VT, VT),
8027 return DAG.getNode(ARMISD::VTRN, dl, DAG.getVTList(VT, VT),
8045 if (V2.getNode()->isUndef())
8046 return DAG.getNode(ARMISD::VTBL1, DL, MVT::v8i8, V1,
8049 return DAG.getNode(ARMISD::VTBL2, DL, MVT::v8i8, V1, V2,
8061 OpLHS = DAG.getNode(ARMISD::VREV64, DL, VT, OpLHS);
8066 return DAG.getNode(ARMISD::VEXT, DL, VT, OpLHS, OpLHS,
8090 AllOnes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v16i8, AllOnes);
8094 AllZeroes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v16i8, AllZeroes);
8105 RecastV1 = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::v16i1, Pred);
8111 DAG.getNode(ISD::VSELECT, dl, MVT::v16i8, RecastV1, AllOnes, AllZeroes);
8115 return DAG.getNode(ISD::BITCAST, dl, NewVT, PredAsVector);
8121 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
8130 SDValue cast = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, V1);
8131 SDValue rbit = DAG.getNode(ISD::BITREVERSE, dl, MVT::i32, cast);
8132 SDValue srl = DAG.getNode(ISD::SRL, dl, MVT::i32, rbit,
8134 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, VT, srl);
8154 return DAG.getNode(ARMISD::VCMPZ, dl, VT, Shuffled,
8212 Parts[Part] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, BitCast,
8235 Parts[Part] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
8250 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
8272 return DAG.getNode(ARMISD::VDUP, dl, VT, V1.getOperand(0));
8286 return DAG.getNode(ARMISD::VDUP, dl, VT, V1.getOperand(0));
8288 return DAG.getNode(ARMISD::VDUPLANE, dl, VT, V1,
8297 return DAG.getNode(ARMISD::VEXT, dl, VT, V1, V2,
8302 return DAG.getNode(ARMISD::VREV64, dl, VT, V1);
8304 return DAG.getNode(ARMISD::VREV32, dl, VT, V1);
8306 return DAG.getNode(ARMISD::VREV16, dl, VT, V1);
8309 return DAG.getNode(ARMISD::VEXT, dl, VT, V1, V1,
8325 return DAG.getNode(ShuffleOpc, dl, DAG.getVTList(VT, VT), V1, V2)
8331 return DAG.getNode(ARMISD::VMOVN, dl, VT, V2, V1,
8334 return DAG.getNode(ARMISD::VMOVN, dl, VT, V1, V2,
8369 SDValue Res = DAG.getNode(ShuffleOpc, dl, DAG.getVTList(SubVT, SubVT),
8371 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Res.getValue(0),
8415 V1 = DAG.getNode(ISD::BITCAST, dl, VecVT, V1);
8416 V2 = DAG.getNode(ISD::BITCAST, dl, VecVT, V2);
8422 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
8427 SDValue Val = DAG.getNode(ARMISD::BUILD_VECTOR, dl, VecVT, Ops);
8428 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
8454 DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Op->getOperand(0));
8459 SDValue Ext = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::i32,
8461 SDValue BFI = DAG.getNode(ARMISD::BFI, dl, MVT::i32, Conv, Ext,
8463 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, Op.getValueType(), BFI);
8498 SDValue IElt = DAG.getNode(ISD::BITCAST, dl, IEltVT, Elt);
8499 SDValue IVecIn = DAG.getNode(ISD::BITCAST, dl, IVecVT, VecIn);
8500 SDValue IVecOut = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, IVecVT,
8502 return DAG.getNode(ISD::BITCAST, dl, VecVT, IVecOut);
8517 DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Op->getOperand(0));
8521 SDValue Shift = DAG.getNode(ISD::SRL, dl, MVT::i32, Conv,
8541 return DAG.getNode(ARMISD::VGETLANEu, dl, MVT::i32, Vec, Lane);
8577 SDValue ConVec = DAG.getNode(ISD::UNDEF, dl, ConcatVT);
8582 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, NewV,
8584 ConVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, ConcatVT, ConVec, Elt,
8595 return DAG.getNode(ARMISD::VCMPZ, dl, VT, ConVec,
8614 Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Val,
8615 DAG.getNode(ISD::BITCAST, dl, MVT::f64, Op0),
8618 Val = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, MVT::v2f64, Val,
8619 DAG.getNode(ISD::BITCAST, dl, MVT::f64, Op1),
8621 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Val);
8647 SDValue SubVec = DAG.getNode(ISD::UNDEF, dl, SubVT);
8649 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, NewV1,
8651 SubVec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, SubVT, SubVec, Elt,
8657 return DAG.getNode(ARMISD::VCMPZ, dl, VT, SubVec,
8669 SDNode *BVN = N->getOperand(0).getNode();
8696 SDNode *Elt = N->getOperand(i).getNode();
8769 return DAG.getNode(ExtOpcode, SDLoc(N), NewVT, N);
8816 DAG.getNode(Opcode, SDLoc(newLoad), LD->getValueType(0), newLoad);
8825 SDNode *BVN = N->getOperand(0).getNode();
8854 SDNode *N0 = N->getOperand(0).getNode();
8855 SDNode *N1 = N->getOperand(1).getNode();
8865 SDNode *N0 = N->getOperand(0).getNode();
8866 SDNode *N1 = N->getOperand(1).getNode();
8879 SDNode *N0 = Op.getOperand(0).getNode();
8880 SDNode *N1 = Op.getOperand(1).getNode();
8927 return DAG.getNode(NewOpc, DL, VT, Op0, Op1);
8938 SDValue N00 = SkipExtensionForVMULL(N0->getOperand(0).getNode(), DAG);
8939 SDValue N01 = SkipExtensionForVMULL(N0->getOperand(1).getNode(), DAG);
8941 return DAG.getNode(N0->getOpcode(), DL, VT,
8942 DAG.getNode(NewOpc, DL, VT,
8943 DAG.getNode(ISD::BITCAST, DL, Op1VT, N00), Op1),
8944 DAG.getNode(NewOpc, DL, VT,
8945 DAG.getNode(ISD::BITCAST, DL, Op1VT, N01), Op1));
8955 X = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, X);
8956 Y = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, Y);
8957 X = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, X);
8958 Y = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, Y);
8961 Y = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
8968 X = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, X, Y);
8969 X = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, X);
8971 X = DAG.getNode(ISD::ADD, dl, MVT::v4i32, X, Y);
8972 X = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, X);
8974 X = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, X);
8975 X = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, X);
8987 N0 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, N0);
8988 N1 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, N1);
8989 N0 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N0);
8990 N1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N1);
8995 N2 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
8998 N1 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
9001 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
9006 N0 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N0, N2);
9007 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, N0);
9009 N0 = DAG.getNode(ISD::ADD, dl, MVT::v4i32, N0, N1);
9010 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, N0);
9013 N0 = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, N0);
9014 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, N0);
9030 N0 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v8i16, N0);
9031 N1 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v8i16, N1);
9033 N2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
9035 N3 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
9037 N0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
9039 N1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
9045 N0 = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v8i16, N0, N2);
9048 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v8i8, N0);
9067 N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v8i16, N0);
9068 N1 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v8i16, N1);
9070 N2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
9072 N3 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
9074 N0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
9076 N1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
9082 N0 = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v8i16, N0, N2);
9085 N0 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v8i8,
9095 N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v4i32, N0);
9096 N1 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v4i32, N1);
9097 N0 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N0);
9098 SDValue BN1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N1);
9104 N2 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
9107 N1 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
9110 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
9111 N1 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
9114 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
9119 N0 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N0, N2);
9120 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, N0);
9122 N0 = DAG.getNode(ISD::ADD, dl, MVT::v4i32, N0, N1);
9123 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, N0);
9126 N0 = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, N0);
9127 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, N0);
9132 SDNode *N = Op.getNode();
9146 Result = DAG.getNode(ARMISD::ADDE, DL, VTs, Op.getOperand(0),
9154 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
9160 Result = DAG.getNode(ARMISD::SUBE, DL, VTs, Op.getOperand(0),
9167 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
9172 return DAG.getNode(ISD::MERGE_VALUES, DL, N->getVTList(), Result, Carry);
9240 SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, SRet,
9246 return DAG.getNode(ISD::MERGE_VALUES, dl, Tys,
9336 SDValue DBZCHK = DAG.getNode(ARMISD::WIN__DBZCHK, dl, MVT::Other,
9346 return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain, Op);
9347 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, Op,
9349 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, Op,
9351 return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain,
9352 DAG.getNode(ISD::OR, DL, MVT::i32, Lo, Hi));
9365 SDValue DBZCHK = WinDBZCheckDenominator(DAG, Op.getNode(), DAG.getEntryNode());
9369 SDValue Lower = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Result);
9370 SDValue Upper = DAG.getNode(ISD::SRL, dl, MVT::i64, Result,
9372 Upper = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Upper);
9374 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lower, Upper));
9378 LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
9400 SDValue Pred = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::v16i1, Load);
9402 Pred = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MemVT, Pred,
9421 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
9427 StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
9442 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, Build,
9446 Build = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v16i1, Ops);
9448 SDValue GRP = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Build);
9457 StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
9463 SDNode *N = Op.getNode();
9466 SDValue Lo = DAG.getNode(
9470 SDValue Hi = DAG.getNode(
9488 return (ISD::isBuildVectorAllZeros(N.getNode()) ||
9494 MaskedLoadSDNode *N = cast<MaskedLoadSDNode>(Op.getNode());
9505 SDValue ZeroVec = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
9516 Combo = DAG.getNode(ISD::VSELECT, dl, VT, Mask, NewLoad, PassThru);
9553 SDValue Rev = DAG.getNode(RevOpcode, dl, VT, Op0);
9554 Op0 = DAG.getNode(BaseOpcode, dl, VT, Op0, Rev);
9561 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9563 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9565 SDValue Ext2 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9567 SDValue Ext3 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9569 SDValue Res0 = DAG.getNode(BaseOpcode, dl, EltVT, Ext0, Ext1, Op->getFlags());
9570 SDValue Res1 = DAG.getNode(BaseOpcode, dl, EltVT, Ext2, Ext3, Op->getFlags());
9571 Res = DAG.getNode(BaseOpcode, dl, EltVT, Res0, Res1, Op->getFlags());
9573 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9575 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Op0,
9577 Res = DAG.getNode(BaseOpcode, dl, EltVT, Ext0, Ext1, Op->getFlags());
9582 Res = DAG.getNode(ISD::ANY_EXTEND, dl, Op->getValueType(0), Res);
9619 SDValue Cycles32 = DAG.getNode(ISD::INTRINSIC_W_CHAIN, DL,
9621 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Cycles32,
9627 SDLoc dl(V.getNode());
9630 DAG.getNode(ISD::SRL, dl, MVT::i64, V, DAG.getConstant(32, dl, MVT::i32)),
9668 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, SDLoc(N), MVT::i64, Lo, Hi));
9686 if (!RHS.getNode()) {
9690 SDValue Result = DAG.getNode(ISD::SETCC, dl, VT, LHS, RHS,
9749 case ISD::BITCAST: return ExpandBITCAST(Op.getNode(), DAG, Subtarget);
9752 case ISD::SRA: return LowerShift(Op.getNode(), DAG, Subtarget);
9753 case ISD::SREM: return LowerREM(Op.getNode(), DAG);
9754 case ISD::UREM: return LowerREM(Op.getNode(), DAG);
9759 case ISD::CTTZ_ZERO_UNDEF: return LowerCTTZ(Op.getNode(), DAG, Subtarget);
9760 case ISD::CTPOP: return LowerCTPOP(Op.getNode(), DAG, Subtarget);
9842 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
9845 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
9849 SDValue LongMul = DAG.getNode(Opc, dl,
9853 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64,
9912 if (Res.getNode())
11498 if (!isConditionalZeroOrAllOnes(Slct.getNode(), AllOnes, CCOp, SwapSelectOps,
11504 SDValue FalseVal = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
11510 return DAG.getNode(ISD::SELECT, SDLoc(N), VT,
11520 if (N0.getNode()->hasOneUse())
11523 if (N1.getNode()->hasOneUse())
11545 if (!IsVUZPShuffleNode(N0.getNode()) || N0.getNode() != N1.getNode() ||
11557 SDNode *Unzip = N0.getNode();
11566 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT, Ops);
11583 if (!IsVUZPShuffleNode(N00.getNode()) || N00.getNode() != N10.getNode() ||
11611 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), ConcatVT,
11615 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, VT, Ops);
11647 SDNode *V = Vec.getNode();
11661 if (V != ExtVec0->getOperand(0).getNode() ||
11662 V != ExtVec1->getOperand(0).getNode())
11714 SDValue tmp = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, widenType, Ops);
11716 return DAG.getNode(ExtOp, dl, VT, tmp);
11789 SDValue SMLAL = DAG.getNode(Opcode, dl, DAG.getVTList(MVT::i32, MVT::i32),
11792 SDValue HiMLALResult(SMLAL.getNode(), 1);
11793 SDValue LoMLALResult(SMLAL.getNode(), 0);
11835 SDNode *AddcSubcNode = AddeSubeNode->getOperand(2).getNode();
11846 if (AddcSubcOp0.getNode() == AddcSubcOp1.getNode())
11867 if (AddeSubeOp0.getNode() == AddeSubeOp1.getNode())
11915 if (AddcSubcNode == HiAddSub->getNode() ||
11916 AddcSubcNode->isPredecessorOf(HiAddSub->getNode()))
11933 LowAddSub->getNode()->getOpcode() == ISD::Constant &&
11934 static_cast<ConstantSDNode *>(LowAddSub->getNode())->getZExtValue() ==
11942 SDValue NewNode = DAG.getNode(FinalOpc, SDLoc(AddcSubcNode), MVT::i32, Ops);
11955 SDValue MLALNode = DAG.getNode(FinalOpc, SDLoc(AddcSubcNode),
11959 SDValue HiMLALResult(MLALNode.getNode(), 1);
11962 SDValue LoMLALResult(MLALNode.getNode(), 0);
11982 SDNode* AddcNode = AddeNode->getOperand(2).getNode();
11990 UmlalNode = AddcNode->getOperand(0).getNode();
11993 UmlalNode = AddcNode->getOperand(1).getNode();
12005 AddeNode->getOperand(1).getNode() == UmlalNode) ||
12006 (AddeNode->getOperand(0).getNode() == UmlalNode &&
12011 SDValue UMAAL = DAG.getNode(ARMISD::UMAAL, SDLoc(AddcNode),
12015 DAG.ReplaceAllUsesOfValueWith(SDValue(AddeNode, 0), SDValue(UMAAL.getNode(), 1));
12016 DAG.ReplaceAllUsesOfValueWith(SDValue(AddcNode, 0), SDValue(UMAAL.getNode(), 0));
12031 SDNode* AddcNode = N->getOperand(2).getNode();
12032 SDNode* AddeNode = N->getOperand(3).getNode();
12037 (AddeNode->getOperand(2).getNode() == AddcNode))
12038 return DAG.getNode(ARMISD::UMAAL, SDLoc(N),
12071 return DAG.getNode(Opcode, DL, N->getVTList(), N->getOperand(0), RHS);
12097 return DAG.getNode(Opcode, DL, N->getVTList(),
12140 return DCI.DAG.getNode(ISD::VSELECT, SDLoc(N), Type, Cond, RHS, LHS);
12194 if (N0.getNode()->hasOneUse())
12221 NB->getOperand(1) != SDValue(VecRed.getNode(), 1))
12226 Ops.push_back(DCI.DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, NA,
12228 Ops.push_back(DCI.DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, NA,
12232 SDValue Red = DCI.DAG.getNode(OpcodeA, dl,
12234 return DCI.DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Red,
12235 SDValue(Red.getNode(), 1));
12412 SDValue BinOp = DAG.getNode(N->getOpcode(), dl, MVT::i32, X,
12415 SDValue Res = DAG.getNode(ISD::SHL, dl, MVT::i32, BinOp, SHL.getOperand(1));
12456 if (N1.getNode()->hasOneUse())
12478 SDValue Negate = DCI.DAG.getNode(ISD::SUB, dl, MVT::i32,
12481 return DCI.DAG.getNode(ARMISD::VDUP, dl, N->getValueType(0), Negate);
12525 return DAG.getNode(Opcode, DL, VT,
12526 DAG.getNode(ISD::MUL, DL, VT, N00, N1),
12527 DAG.getNode(ISD::MUL, DL, VT, N01, N1));
12579 SDValue New0a = DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, MVT::v4i32, Op0);
12580 SDValue New1a = DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, MVT::v4i32, Op1);
12581 return DAG.getNode(ARMISD::VMULLs, dl, VT, New0a, New1a);
12586 SDValue New0a = DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, MVT::v4i32, Op0);
12587 SDValue New1a = DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, MVT::v4i32, Op1);
12588 return DAG.getNode(ARMISD::VMULLu, dl, VT, New0a, New1a);
12632 Res = DAG.getNode(ISD::ADD, DL, VT,
12634 DAG.getNode(ISD::SHL, DL, VT,
12640 Res = DAG.getNode(ISD::SUB, DL, VT,
12641 DAG.getNode(ISD::SHL, DL, VT,
12652 Res = DAG.getNode(ISD::SUB, DL, VT,
12654 DAG.getNode(ISD::SHL, DL, VT,
12660 Res = DAG.getNode(ISD::ADD, DL, VT,
12662 DAG.getNode(ISD::SHL, DL, VT,
12666 Res = DAG.getNode(ISD::SUB, DL, VT,
12673 Res = DAG.getNode(ISD::SHL, DL, VT,
12700 SDNode *N0 = N->getOperand(0).getNode();
12735 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
12737 return DAG.getNode(ISD::SRL, DL, MVT::i32, SHL,
12746 SDValue SHL = DAG.getNode(ISD::SRL, DL, MVT::i32, N0->getOperand(0),
12748 return DAG.getNode(ISD::SHL, DL, MVT::i32, SHL,
12759 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
12761 return DAG.getNode(ISD::SRL, DL, MVT::i32, SHL,
12772 SDValue SHL = DAG.getNode(ISD::SRL, DL, MVT::i32, N0->getOperand(0),
12774 return DAG.getNode(ISD::SHL, DL, MVT::i32, SHL,
12809 if (Val.getNode()) {
12811 DAG.getNode(ISD::BITCAST, dl, VbicVT, N->getOperand(0));
12812 SDValue Vbic = DAG.getNode(ARMISD::VBICIMM, dl, VbicVT, Input, Val);
12813 return DAG.getNode(ISD::BITCAST, dl, VT, Vbic);
12855 if ((SRL.getOperand(0).getNode() != SHL.getOperand(0).getNode()) ||
12859 SDNode *SMULLOHI = SRL.getOperand(0).getNode();
12890 SDValue Res = DAG.getNode(Opcode, dl, MVT::i32, OpS32, OpS16);
12943 Res = DAG.getNode(ARMISD::BFI, DL, VT, N00,
12970 Res = DAG.getNode(ISD::SRL, DL, VT, N1.getOperand(0),
12972 Res = DAG.getNode(ARMISD::BFI, DL, VT, N00, Res,
12987 Res = DAG.getNode(ISD::SRL, DL, VT, N00,
12989 Res = DAG.getNode(ARMISD::BFI, DL, VT, N1.getOperand(0), Res,
13009 Res = DAG.getNode(ARMISD::BFI, DL, VT, N1, N00.getOperand(0),
13074 SDValue And = DCI.DAG.getNode(ISD::AND, DL, VT, NewN0, NewN1);
13106 if (Val.getNode()) {
13108 DAG.getNode(ISD::BITCAST, dl, VorrVT, N->getOperand(0));
13109 SDValue Vorr = DAG.getNode(ARMISD::VORRIMM, dl, VorrVT, Input, Val);
13110 return DAG.getNode(ISD::BITCAST, dl, VT, Vorr);
13156 SDValue Result = DAG.getNode(ARMISD::VBSL, dl, CanonicalVT,
13160 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
13202 if (TLI->isConstTrueVal(N1.getNode()) &&
13213 return DCI.DAG.getNode(N0->getOpcode(), DL, N0->getValueType(0), Ops);
13267 SDValue NewFrom = ParseBFI(V.getNode(), NewToMask, NewFromMask);
13315 return DCI.DAG.getNode(ARMISD::BFI, SDLoc(N), N->getValueType(0),
13331 SDValue From2 = ParseBFI(CombineBFI.getNode(), ToMask2, FromMask2);
13345 From1 = DCI.DAG.getNode(
13348 return DCI.DAG.getNode(ARMISD::BFI, dl, VT, N->getOperand(0), From1,
13365 SDNode *InNode = InDouble.getNode();
13380 SDValue OffsetPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr,
13409 Op0.getNode() == Op1.getNode() &&
13411 return DAG.getNode(ISD::BITCAST, SDLoc(N),
13435 DCI.DAG.getNode(ISD::CopyFromReg, SDLoc(N), N->getValueType(0), Ops);
13468 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse()) {
13482 return DCI.DAG.getNode(ARMISD::VGETLANEu, SDLoc(N), VT, N0->getOperand(0),
13495 SDNode *Elt = N->getOperand(i).getNode();
13525 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::f64, N->getOperand(i));
13528 DCI.AddToWorklist(V.getNode());
13532 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
13614 V = DAG.getNode(ISD::BITCAST, SDLoc(V), MVT::i32, V);
13616 DCI.AddToWorklist(V.getNode());
13619 Vec = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VecVT, Vec, V, LaneIdx);
13621 Vec = DAG.getNode(ISD::BITCAST, dl, VT, Vec);
13623 DCI.AddToWorklist(Vec.getNode());
13638 return DCI.DAG.getNode(ARMISD::PREDICATE_CAST, dl, VT, Op->getOperand(0));
13653 return DCI.DAG.getNode(ISD::BITCAST, dl, VT, Op);
13660 return DCI.DAG.getNode(ARMISD::VECTOR_REG_CAST, dl, VT, Op->getOperand(0));
13681 return DCI.DAG.getNode(ARMISD::VCMPZ, dl, VT, Op0,
13688 return DCI.DAG.getNode(ARMISD::VCMPZ, dl, VT, Op1,
13692 return DCI.DAG.getNode(ARMISD::VCMP, dl, VT, Op1, Op0,
13706 SDNode *Elt = N->getOperand(1).getNode();
13715 SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, N->getOperand(0));
13716 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::f64, N->getOperand(1));
13718 DCI.AddToWorklist(Vec.getNode());
13719 DCI.AddToWorklist(V.getNode());
13720 SDValue InsElt = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, FloatVT,
13722 return DAG.getNode(ISD::BITCAST, dl, VT, InsElt);
13735 return DCI.DAG.getNode(ARMISD::VMOVhr, dl, VT, X);
13737 return DCI.DAG.getNode(ARMISD::VMOVrh, dl, VT, X);
13780 SDValue NewConcat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
13817 for (SDNode::use_iterator UI = Addr.getNode()->use_begin(),
13818 UE = Addr.getNode()->use_end(); UI != UE; ++UI) {
13829 Visited.insert(Addr.getNode());
13912 ConstantSDNode *CInc = dyn_cast<ConstantSDNode>(Inc.getNode());
13993 StVal = DAG.getNode(ISD::BITCAST, dl, AlignedVecTy, StVal);
14003 NewResults.push_back(SDValue(UpdN.getNode(), i));
14009 LdVal = DAG.getNode(ISD::BITCAST, dl, VecTy, LdVal);
14012 NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs+1)); // chain
14014 DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
14050 for (SDNode::use_iterator UI = Addr.getNode()->use_begin(),
14051 UE = Addr.getNode()->use_end();
14063 Visited.insert(Addr.getNode());
14109 ConstantSDNode *CInc = dyn_cast<ConstantSDNode>(Inc.getNode());
14139 NewResults.push_back(SDValue(UpdN.getNode(), i));
14141 NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs + 1)); // chain
14143 DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
14163 SDNode *VLD = N->getOperand(0).getNode();
14218 DCI.CombineTo(User, SDValue(VLDDup.getNode(), ResNo));
14225 VLDDupResults.push_back(SDValue(VLDDup.getNode(), n));
14226 VLDDupResults.push_back(SDValue(VLDDup.getNode(), NumVecs));
14246 SDValue Extract = DCI.DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), ExtractVT,
14248 return DCI.DAG.getNode(ARMISD::VDUP, SDLoc(N), VT, Extract);
14273 return DCI.DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
14288 return DCI.DAG.getNode(ARMISD::VDUP, dl, N->getValueType(0),
14289 DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op));
14291 return DCI.DAG.getNode(ARMISD::VDUP, dl, N->getValueType(0),
14292 DAG.getNode(ARMISD::VMOVrh, dl, MVT::i32, Op));
14301 LoadSDNode *LD = dyn_cast<LoadSDNode>(Op.getNode());
14363 SDValue WideVec = DAG.getNode(ISD::BITCAST, DL, WideVecVT, StVal);
14393 SDValue ShuffWide = DAG.getNode(ISD::BITCAST, DL, StoreVecVT, Shuff);
14402 SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, StoreType,
14408 DAG.getNode(ISD::ADD, DL, BasePtr.getValueType(), BasePtr, Increment);
14411 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
14492 DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewFromVT, Trunc.getOperand(0),
14497 DAG.getNode(ARMISD::VCVTN, DL, MVT::v8f16, DAG.getUNDEF(MVT::v8f16),
14499 Extract = DAG.getNode(ARMISD::VECTOR_REG_CAST, DL, MVT::v4i32, FPTrunc);
14507 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Stores);
14534 if (StVal.getNode()->getOpcode() == ARMISD::VMOVDRR &&
14535 StVal.getNode()->hasOneUse()) {
14541 St->getChain(), DL, StVal.getNode()->getOperand(isBigEndian ? 1 : 0),
14545 SDValue OffsetPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr,
14548 StVal.getNode()->getOperand(isBigEndian ? 0 : 1),
14555 StVal.getNode()->getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
14564 SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, IntVec);
14565 SDValue ExtElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
14568 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ExtElt);
14570 DCI.AddToWorklist(Vec.getNode());
14571 DCI.AddToWorklist(ExtElt.getNode());
14572 DCI.AddToWorklist(V.getNode());
14632 SDValue FixConv = DAG.getNode(
14638 FixConv = DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), FixConv);
14658 unsigned OpOpcode = Op.getNode()->getOpcode();
14690 ConvInput = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
14696 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl,
14748 SDValue Node = DAG.getNode(Opcode, dl, {MVT::i32, MVT::i32}, Ops);
14749 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Node,
14750 SDValue(Node.getNode(), 1));
14754 return DAG.getNode(ARMISD::VADDVs, dl, ResVT, A);
14756 return DAG.getNode(ARMISD::VADDVu, dl, ResVT, A);
14764 return DAG.getNode(ARMISD::VMLAVs, dl, ResVT, A, B);
14766 return DAG.getNode(ARMISD::VMLAVu, dl, ResVT, A, B);
14785 return DCI.DAG.getNode(Op1->getOpcode(), SDLoc(Op1), N->getValueType(0),
14838 DAG.ReplaceAllUsesWith(N, Merge.getNode());
14845 SDValue NewShift = DAG.getNode(NewOpcode, DL, N->getVTList(), Op0, Op1,
14847 DAG.ReplaceAllUsesWith(N, NewShift.getNode());
14980 return DAG.getNode(VShiftOpc, dl, N->getValueType(0),
14998 return DAG.getNode(VShiftOpc, dl, N->getValueType(0),
15051 return DAG.getNode(Opc, SDLoc(N), N->getVTList(), N->getOperand(1));
15069 SDValue val = DAG.getNode(Opc, dl, {MVT::i32, MVT::i32}, Ops);
15070 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, val.getValue(0),
15097 return DAG.getNode(ISD::ROTR, SDLoc(N), VT, N0, N1);
15126 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
15128 return DAG.getNode(
15150 return DAG.getNode(ARMISD::VSHLIMM, dl, VT, N->getOperand(0),
15161 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0),
15176 LoadSDNode *LD = cast<LoadSDNode>(N0.getNode());
15229 Chains.push_back(SDValue(NewLoad.getNode(), 1));
15238 DAG.getNode(ARMISD::VECTOR_REG_CAST, DL, MVT::v8f16, Loads[i]);
15239 SDValue FPExt = DAG.getNode(ARMISD::VCVTL, DL, MVT::v4f32, LoadBC,
15247 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
15249 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ToVT, Loads);
15286 return DAG.getNode(Opc, SDLoc(N), VT, Vec, Lane);
15332 if (!ISD::isConstantSplatVector(Min->getOperand(1).getNode(), MinC) ||
15335 if (!ISD::isConstantSplatVector(Max->getOperand(1).getNode(), MaxC) ||
15341 if (IsSignedSaturate(N, N0.getNode())) {
15356 DAG.getNode(ARMISD::VQMOVNs, DL, HalfVT, DAG.getUNDEF(HalfVT),
15358 SDValue Bitcast = DAG.getNode(ARMISD::VECTOR_REG_CAST, DL, VT, VQMOVN);
15359 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, Bitcast,
15375 if (!ISD::isConstantSplatVector(Min->getOperand(1).getNode(), MinC) ||
15397 DAG.getNode(ARMISD::VQMOVNu, DL, HalfVT, DAG.getUNDEF(HalfVT), N0,
15399 SDValue Bitcast = DAG.getNode(ARMISD::VECTOR_REG_CAST, DL, VT, VQMOVN);
15400 return DAG.getNode(ISD::AND, DL, VT, Bitcast,
15487 X = DAG.getNode(ISD::SRL, dl, VT, X,
15497 V = DAG.getNode(ARMISD::BFI, dl, VT, V, X,
15625 SDValue NewBr = DAG.getNode(ISD::BR, SDLoc(Br), MVT::Other, NewBrOps);
15634 Res = DAG.getNode(ARMISD::WLS, dl, MVT::Other, Ops);
15641 Res = DAG.getNode(ARMISD::WLS, dl, MVT::Other, Ops);
15649 SDValue LoopDec = DAG.getNode(ARMISD::LOOP_DEC, dl,
15651 DAG.ReplaceAllUsesWith(Int.getNode(), LoopDec.getNode());
15661 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
15662 SDValue(LoopDec.getNode(), 1), Chain);
15664 SDValue EndArgs[] = { Chain, SDValue(LoopDec.getNode(), 0), Target };
15665 return DAG.getNode(ARMISD::LE, dl, MVT::Other, EndArgs);
15701 return DAG.getNode(
15754 Res = DAG.getNode(ARMISD::CMOV, dl, VT, LHS, TrueVal, ARMcc,
15759 Res = DAG.getNode(ARMISD::CMOV, dl, VT, LHS, FalseVal, ARMcc,
15772 return DAG.getNode(ARMISD::CMOV, dl, VT, FalseVal, TrueVal,
15788 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, LHS, RHS);
15789 Res = DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::CTLZ, dl, VT, Sub),
15801 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, LHS, RHS);
15803 SDValue Neg = DAG.getNode(ISD::USUBO, dl, VTs, FalseVal, Sub);
15807 DAG.getNode(ISD::SUB, dl, MVT::i32,
15809 Res = DAG.getNode(ISD::ADDCARRY, dl, VTs, Sub, Neg, Carry);
15816 DAG.getNode(ARMISD::SUBS, dl, DAG.getVTList(VT, MVT::i32), LHS, RHS);
15819 Res = DAG.getNode(ARMISD::CMOV, dl, VT, Sub, TrueVal, ARMcc,
15830 DAG.getNode(ARMISD::SUBS, dl, DAG.getVTList(VT, MVT::i32), LHS, RHS);
15833 Res = DAG.getNode(ARMISD::CMOV, dl, VT, Sub, FalseVal,
15863 SDValue Subc = DAG.getNode(ISD::USUBO, dl, VTs, FalseVal, TrueVal);
15864 Res = DAG.getNode(ISD::SUBCARRY, dl, VTs, FalseVal, Subc, Subc.getValue(1));
15867 Res = DAG.getNode(ISD::SHL, dl, VT, Res,
15871 if (Res.getNode()) {
15875 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
15878 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
15881 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
15897 return DAG.getNode(ARMISD::VDUP, SDLoc(N), DstVT, Src.getOperand(0));
15913 return DAG.getNode(ARMISD::VECTOR_REG_CAST, SDLoc(N), DstVT, Src);
16414 !ExtVal->use_begin()->isOnlyUserOf(ExtVal.getNode()))
16927 Ptr.getNode(), VT, Alignment, isSEXTLoad, IsMasked,
16931 isLegal = getT2IndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
16934 isLegal = getARMIndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
17103 ConstantSDNode *Pos = cast<ConstantSDNode>(Op.getOperand(1).getNode());
17183 SDValue NewOp = TLO.DAG.getNode(ISD::AND, DL, VT, Op.getOperand(0), NewC);
17233 Op, TLO.DAG.getNode(
17599 if (Result.getNode()) {
17672 SDValue Div = DAG.getNode(DivOpcode, dl, VT, Dividend, Divisor);
17673 SDValue Mul = DAG.getNode(ISD::MUL, dl, VT, Div, Divisor);
17674 SDValue Rem = DAG.getNode(ISD::SUB, dl, VT, Dividend, Mul);
17677 return DAG.getNode(ISD::MERGE_VALUES, dl, DAG.getVTList(VT, VT), Values);
17680 RTLIB::Libcall LC = getDivRemLibcall(Op.getNode(),
17684 TargetLowering::ArgListTy Args = getDivRemArgList(Op.getNode(),
17694 InChain = WinDBZCheckDenominator(DAG, Op.getNode(), InChain);
17745 SDNode *ResNode = CallResult.first.getNode();
17765 SP = DAG.getNode(ISD::SUB, DL, MVT::i32, SP, Size);
17768 DAG.getNode(ISD::AND, DL, MVT::i32, SP.getValue(0),
17775 SDValue Words = DAG.getNode(ISD::SRL, DL, MVT::i32, Size,
17783 Chain = DAG.getNode(ARMISD::WIN__CHKSTK, DL, NodeTys, Chain, Flag);
17811 SDValue Result = DAG.getNode(ISD::FP_EXTEND,
17833 SrcVal = DAG.getNode(ISD::STRICT_FP_EXTEND, Loc,
17837 SrcVal = DAG.getNode(ISD::FP_EXTEND, Loc, DstVT, SrcVal);
17898 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
17900 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
17903 Tmp = DAG.getNode(ISD::SRA, dl, HalfT, Hi,
17906 Lo = DAG.getNode(ISD::UADDO, dl, VTList, Tmp, Lo);
17907 Hi = DAG.getNode(ISD::ADDCARRY, dl, VTList, Tmp, Hi,
17908 SDValue(Lo.getNode(), 1));
17909 Hi = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Hi);
17910 Lo = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Lo);