Lines Matching refs:SDValue
169 inline SDValue getI16Imm(unsigned Imm, const SDLoc &dl) {
175 inline SDValue getI32Imm(unsigned Imm, const SDLoc &dl) {
181 inline SDValue getI64Imm(uint64_t Imm, const SDLoc &dl) {
186 inline SDValue getSmallIPtrImm(unsigned Imm, const SDLoc &dl) {
220 SDValue SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC,
226 bool SelectAddrImmOffs(SDValue N, SDValue &Out) const {
242 bool SelectAddrIdx(SDValue N, SDValue &Base, SDValue &Index) {
252 bool SelectAddrIdxX4(SDValue N, SDValue &Base, SDValue &Index) {
263 bool SelectAddrIdxX16(SDValue N, SDValue &Base, SDValue &Index) {
270 bool SelectAddrIdxOnly(SDValue N, SDValue &Base, SDValue &Index) {
278 bool SelectAddrImm(SDValue N, SDValue &Disp,
279 SDValue &Base) {
286 bool SelectAddrImmX4(SDValue N, SDValue &Disp, SDValue &Base) {
293 bool SelectAddrImmX16(SDValue N, SDValue &Disp, SDValue &Base) {
299 bool SelectAddr(SDValue N, SDValue &Base) {
304 bool SelectAddrPCRel(SDValue N, SDValue &Base) {
313 bool SelectInlineAsmMemoryOperand(const SDValue &Op,
315 std::vector<SDValue> &OutOps) override {
331 SDValue RC = CurDAG->getTargetConstant(TRC->getID(), dl, MVT::i32);
332 SDValue NewOp =
333 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
366 SDValue combineToCMPB(SDNode *N);
367 void foldBoolExts(SDValue &Res, SDNode *&N);
520 static bool isInt32Immediate(SDValue N, unsigned &Imm) {
526 static bool isInt64Immediate(SDValue N, uint64_t &Imm) {
532 const SDValue &DestMBB) {
592 SDValue TFI = CurDAG->getTargetFrameIndex(FI, N->getValueType(0));
645 SDValue Base = ST->getBasePtr();
648 SDValue Offset = ST->getOffset();
677 SDValue Chain = ST->getChain();
679 SDValue Ops[] = {ST->getValue(), Base.getOperand(0), Base.getOperand(1),
688 SDValue Base = LD->getBasePtr();
691 SDValue Offset = LD->getOffset();
719 SDValue Chain = LD->getChain();
721 SDValue Ops[] = {Base.getOperand(0), Base.getOperand(1), Chain};
731 SDValue Op0 = N->getOperand(0);
732 SDValue Op1 = N->getOperand(1);
794 SDValue Ops[] = { Op0, Op1, getI32Imm(SH, dl), getI32Imm(MB, dl),
941 SDValue SDImm = CurDAG->getTargetConstant(SextImm, dl, MVT::i64);
950 SDValue(Result, 0), getI32Imm(Lo));
962 SDValue Ops[] =
963 { SDValue(Result, 0), SDValue(Result, 0), getI32Imm(Shift), getI32Imm(0)};
970 SDValue(Result, 0),
978 SDValue(Result, 0), getI32Imm(Hi));
982 SDValue(Result, 0), getI32Imm(Lo));
1043 SDValue Val = SDValue(selectI64ImmDirect(CurDAG, dl, MatImm), 0);
1112 SDValue SDImm = CurDAG->getTargetConstant(SextImm, dl, MVT::i64);
1123 SDValue V;
1139 ValueBit(SDValue V, unsigned I, Kind K = Variable)
1142 : V(SDValue(nullptr, 0)), Idx(UINT32_MAX), K(K) {}
1152 SDValue getValue() const {
1165 SDValue V;
1179 BitGroup(SDValue V, unsigned R, unsigned S, unsigned E)
1190 SDValue V;
1224 DenseMap<SDValue, std::unique_ptr<ValueBitsMemoizedValue>>;
1231 std::pair<bool, SmallVector<ValueBit, 64> *> getValueBits(SDValue V,
1316 SDValue LastVal = SDValue();
1349 if (LastVal) LastVal = SDValue();
1482 SDValue LastValue = Bits[0].hasValue() ? Bits[0].getValue() : SDValue();
1487 SDValue ThisValue = Bits[i].hasValue() ? Bits[i].getValue() : SDValue();
1543 // Take all (SDValue, RLAmt) pairs and sort them by the number of groups
1721 SDValue getI32Imm(unsigned Imm, const SDLoc &dl) {
1740 SDValue ExtendToInt64(SDValue V, const SDLoc &dl) {
1745 SDValue SubRegIdx = CurDAG->getTargetConstant(PPC::sub_32, dl, MVT::i32);
1746 SDValue ImDef = SDValue(CurDAG->getMachineNode(PPC::IMPLICIT_DEF, dl,
1748 SDValue ExtVal = SDValue(CurDAG->getMachineNode(PPC::INSERT_SUBREG, dl,
1754 SDValue TruncateToInt32(SDValue V, const SDLoc &dl) {
1759 SDValue SubRegIdx = CurDAG->getTargetConstant(PPC::sub_32, dl, MVT::i32);
1760 SDValue SubVal = SDValue(CurDAG->getMachineNode(PPC::EXTRACT_SUBREG, dl,
1768 void SelectAndParts32(const SDLoc &dl, SDValue &Res, unsigned *InstCnt) {
1820 SDValue VRot;
1822 SDValue Ops[] =
1825 VRot = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32,
1831 SDValue ANDIVal, ANDISVal;
1833 ANDIVal = SDValue(CurDAG->getMachineNode(PPC::ANDI_rec, dl, MVT::i32,
1838 SDValue(CurDAG->getMachineNode(PPC::ANDIS_rec, dl, MVT::i32, VRot,
1842 SDValue TotalVal;
1848 TotalVal = SDValue(CurDAG->getMachineNode(PPC::OR, dl, MVT::i32,
1854 Res = SDValue(CurDAG->getMachineNode(PPC::OR, dl, MVT::i32,
1868 SDValue Res;
1882 SDValue Ops[] =
1885 Res = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops),
1902 SDValue Ops[] =
1906 Res = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops), 0);
1908 SDValue Ops[] =
1912 Res = SDValue(CurDAG->getMachineNode(PPC::RLWIMI, dl, MVT::i32, Ops), 0);
1927 SDValue ANDIVal, ANDISVal;
1929 ANDIVal = SDValue(CurDAG->getMachineNode(PPC::ANDI_rec, dl, MVT::i32,
1934 SDValue(CurDAG->getMachineNode(PPC::ANDIS_rec, dl, MVT::i32, Res,
1943 Res = SDValue(CurDAG->getMachineNode(PPC::OR, dl, MVT::i32,
1970 SDValue SelectRotMask64(SDValue V, const SDLoc &dl, unsigned RLAmt,
1986 SDValue Ops[] =
1989 return SDValue(CurDAG->getMachineNode(PPC::RLWINM8, dl, MVT::i64,
1994 SDValue Ops[] =
1997 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, Ops), 0);
2001 SDValue Ops[] =
2004 return SDValue(CurDAG->getMachineNode(PPC::RLDICR, dl, MVT::i64, Ops), 0);
2008 SDValue Ops[] =
2011 return SDValue(CurDAG->getMachineNode(PPC::RLDIC, dl, MVT::i64, Ops), 0);
2034 SDValue SelectRotMaskIns64(SDValue Base, SDValue V, const SDLoc &dl,
2050 SDValue Ops[] =
2053 return SDValue(CurDAG->getMachineNode(PPC::RLWIMI8, dl, MVT::i64,
2058 SDValue Ops[] =
2061 return SDValue(CurDAG->getMachineNode(PPC::RLDIMI, dl, MVT::i64, Ops), 0);
2082 void SelectAndParts64(const SDLoc &dl, SDValue &Res, unsigned *InstCnt) {
2191 SDValue VRot;
2202 SDValue TotalVal;
2207 SDValue ANDIVal, ANDISVal;
2209 ANDIVal = SDValue(CurDAG->getMachineNode(PPC::ANDI8_rec, dl, MVT::i64,
2215 SDValue(CurDAG->getMachineNode(PPC::ANDIS8_rec, dl, MVT::i64,
2225 TotalVal = SDValue(CurDAG->getMachineNode(PPC::OR8, dl, MVT::i64,
2228 TotalVal = SDValue(selectI64Imm(CurDAG, dl, Mask), 0);
2230 SDValue(CurDAG->getMachineNode(PPC::AND8, dl, MVT::i64,
2238 Res = SDValue(CurDAG->getMachineNode(PPC::OR8, dl, MVT::i64,
2251 SDValue Res;
2357 SDValue ANDIVal, ANDISVal;
2359 ANDIVal = SDValue(CurDAG->getMachineNode(PPC::ANDI8_rec, dl, MVT::i64,
2365 SDValue(CurDAG->getMachineNode(PPC::ANDIS8_rec, dl, MVT::i64,
2375 Res = SDValue(CurDAG->getMachineNode(PPC::OR8, dl, MVT::i64,
2380 SDValue MaskVal = SDValue(selectI64Imm(CurDAG, dl, Mask), 0);
2382 SDValue(CurDAG->getMachineNode(PPC::AND8, dl, MVT::i64,
2424 DenseMap<std::pair<SDValue, unsigned>, ValueRotInfo> ValueRots;
2439 getValueBits(SDValue(N, 0), N->getValueType(0).getSizeInBits());
2509 SDValue computeLogicOpInGPR(SDValue LogicOp);
2510 SDValue signExtendInputIfNeeded(SDValue Input);
2511 SDValue zeroExtendInputIfNeeded(SDValue Input);
2512 SDValue addExtOrTrunc(SDValue NatWidthRes, ExtOrTruncConversion Conv);
2513 SDValue getCompoundZeroComparisonInGPR(SDValue LHS, SDLoc dl,
2515 SDValue get32BitZExtCompare(SDValue LHS, SDValue RHS, ISD::CondCode CC,
2517 SDValue get32BitSExtCompare(SDValue LHS, SDValue RHS, ISD::CondCode CC,
2519 SDValue get64BitZExtCompare(SDValue LHS, SDValue RHS, ISD::CondCode CC,
2521 SDValue get64BitSExtCompare(SDValue LHS, SDValue RHS, ISD::CondCode CC,
2523 SDValue getSETCCInGPR(SDValue Compare, SetccInGPROpts ConvOpts);
2565 SDValue WideRes;
2590 SDValue ConvOp = WideRes;
2606 SDValue LoweredLogical = computeLogicOpInGPR(SDValue(N, 0));
2613 SDValue CR0Reg = CurDAG->getRegister(PPC::CR0, MVT::i32);
2614 SDValue LHS = LoweredLogical.getOperand(0);
2615 SDValue RHS = LoweredLogical.getOperand(1);
2616 SDValue WideOp;
2617 SDValue OpToConvToRecForm;
2645 std::vector<SDValue> Ops;
2650 SDValue(CurDAG->getMachineNode(NewOpc, dl,
2657 SDValue(CurDAG->getMachineNode(NewOpc == -1 ? PPC::ANDI8_rec : NewOpc,
2666 SDValue SRIdxVal =
2668 SDValue CRBit =
2669 SDValue(CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG, dl,
2683 SDValue IntegerCompareEliminator::computeLogicOpInGPR(SDValue LogicOp) {
2689 SDValue LHS, RHS;
2698 auto getLogicOperand = [&] (SDValue Operand) -> SDValue {
2703 SDValue InputOp = Operand.getOperand(0);
2705 return SDValue(CurDAG->getMachineNode(InVT == MVT::i32 ? PPC::RLDICL_32 :
2711 return SDValue();
2720 return SDValue();
2743 return SDValue(CurDAG->getMachineNode(NewOpc, dl, MVT::i64, LHS, RHS), 0);
2751 SDValue IntegerCompareEliminator::signExtendInputIfNeeded(SDValue Input) {
2776 return SDValue(CurDAG->getMachineNode(PPC::EXTSW_32_64, dl,
2784 SDValue IntegerCompareEliminator::zeroExtendInputIfNeeded(SDValue Input) {
2811 return SDValue(CurDAG->getMachineNode(PPC::RLDICL_32_64, dl, MVT::i64, Input,
2820 SDValue IntegerCompareEliminator::addExtOrTrunc(SDValue NatWidthRes,
2827 SDValue ImDef(CurDAG->getMachineNode(PPC::IMPLICIT_DEF, dl, MVT::i64), 0);
2828 SDValue SubRegIdx =
2830 return SDValue(CurDAG->getMachineNode(PPC::INSERT_SUBREG, dl, MVT::i64,
2838 SDValue SubRegIdx =
2840 return SDValue(CurDAG->getMachineNode(PPC::EXTRACT_SUBREG, dl, MVT::i32,
2846 SDValue
2847 IntegerCompareEliminator::getCompoundZeroComparisonInGPR(SDValue LHS, SDLoc dl,
2851 SDValue ToExtend;
2857 ToExtend = SDValue(CurDAG->getMachineNode(Is32Bit ? PPC::NOR : PPC::NOR8,
2865 SDValue Neg =
2866 SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64, LHS), 0);
2868 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
2872 SDValue Addi =
2873 SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, LHS,
2875 ToExtend = SDValue(CurDAG->getMachineNode(PPC::OR8, dl, MVT::i64,
2885 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
2890 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, ToExtend,
2897 SDValue ShiftOps[] = { ToExtend, S->getI32Imm(1, dl), S->getI32Imm(31, dl),
2899 return SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32,
2903 return SDValue(CurDAG->getMachineNode(PPC::SRAWI, dl, MVT::i32, ToExtend,
2906 return SDValue(CurDAG->getMachineNode(PPC::XORI8, dl, MVT::i64, ToExtend,
2909 return SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, ToExtend,
2920 SDValue
2921 IntegerCompareEliminator::get32BitZExtCompare(SDValue LHS, SDValue RHS,
2926 return SDValue();
2931 default: return SDValue();
2935 SDValue Xor = IsRHSZero ? LHS :
2936 SDValue(CurDAG->getMachineNode(PPC::XOR, dl, MVT::i32, LHS, RHS), 0);
2937 SDValue Clz =
2938 SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Xor), 0);
2939 SDValue ShiftOps[] = { Clz, S->getI32Imm(27, dl), S->getI32Imm(5, dl),
2941 return SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32,
2947 SDValue Xor = IsRHSZero ? LHS :
2948 SDValue(CurDAG->getMachineNode(PPC::XOR, dl, MVT::i32, LHS, RHS), 0);
2949 SDValue Clz =
2950 SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Xor), 0);
2951 SDValue ShiftOps[] = { Clz, S->getI32Imm(27, dl), S->getI32Imm(5, dl),
2953 SDValue Shift =
2954 SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, ShiftOps), 0);
2955 return SDValue(CurDAG->getMachineNode(PPC::XORI, dl, MVT::i32, Shift,
2973 return SDValue();
2978 return SDValue();
2985 SDValue Sub =
2986 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, LHS, RHS), 0);
2987 SDValue Shift =
2988 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, Sub,
2992 SDValue(CurDAG->getMachineNode(PPC::XORI8, dl,
3005 return SDValue();
3009 SDValue Neg =
3010 SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64, LHS), 0);
3011 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3029 return SDValue();
3034 SDValue ShiftOps[] = { LHS, S->getI32Imm(1, dl), S->getI32Imm(31, dl),
3036 return SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32,
3041 return SDValue();
3045 SDValue SUBFNode =
3046 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, RHS, LHS), 0);
3047 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3058 return SDValue();
3062 SDValue Subtract =
3063 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, LHS, RHS), 0);
3064 SDValue SrdiNode =
3065 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3068 return SDValue(CurDAG->getMachineNode(PPC::XORI8, dl, MVT::i64, SrdiNode,
3078 return SDValue();
3082 SDValue Subtract =
3083 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, RHS, LHS), 0);
3084 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3093 SDValue
3094 IntegerCompareEliminator::get32BitSExtCompare(SDValue LHS, SDValue RHS,
3099 return SDValue();
3105 default: return SDValue();
3111 SDValue CountInput = IsRHSZero ? LHS :
3112 SDValue(CurDAG->getMachineNode(PPC::XOR, dl, MVT::i32, LHS, RHS), 0);
3113 SDValue Cntlzw =
3114 SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, CountInput), 0);
3115 SDValue SHLOps[] = { Cntlzw, S->getI32Imm(27, dl),
3117 SDValue Slwi =
3118 SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, SHLOps), 0);
3119 return SDValue(CurDAG->getMachineNode(PPC::NEG, dl, MVT::i32, Slwi), 0);
3129 SDValue Xor = IsRHSZero ? LHS :
3130 SDValue(CurDAG->getMachineNode(PPC::XOR, dl, MVT::i32, LHS, RHS), 0);
3131 SDValue Clz =
3132 SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Xor), 0);
3133 SDValue ShiftOps[] =
3135 SDValue Shift =
3136 SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, ShiftOps), 0);
3137 SDValue Xori =
3138 SDValue(CurDAG->getMachineNode(PPC::XORI, dl, MVT::i32, Shift,
3140 return SDValue(CurDAG->getMachineNode(PPC::NEG, dl, MVT::i32, Xori), 0);
3157 return SDValue();
3166 SDValue SUBFNode =
3167 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, MVT::Glue,
3169 SDValue Srdi =
3170 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3173 return SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, Srdi,
3184 return SDValue();
3188 SDValue Neg =
3189 SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64, LHS), 0);
3190 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, Neg,
3207 return SDValue();
3211 return SDValue(CurDAG->getMachineNode(PPC::SRAWI, dl, MVT::i32, LHS,
3215 return SDValue();
3219 SDValue SUBFNode =
3220 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, RHS, LHS), 0);
3221 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64,
3231 return SDValue();
3235 SDValue Subtract =
3236 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, LHS, RHS), 0);
3237 SDValue Shift =
3238 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, Subtract,
3241 return SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, Shift,
3251 return SDValue();
3255 SDValue Subtract =
3256 SDValue(CurDAG->getMachineNode(PPC::SUBF8, dl, MVT::i64, RHS, LHS), 0);
3257 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64,
3265 SDValue
3266 IntegerCompareEliminator::get64BitZExtCompare(SDValue LHS, SDValue RHS,
3271 return SDValue();
3276 default: return SDValue();
3280 SDValue Xor = IsRHSZero ? LHS :
3281 SDValue(CurDAG->getMachineNode(PPC::XOR8, dl, MVT::i64, LHS, RHS), 0);
3282 SDValue Clz =
3283 SDValue(CurDAG->getMachineNode(PPC::CNTLZD, dl, MVT::i64, Xor), 0);
3284 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, Clz,
3293 SDValue Xor = IsRHSZero ? LHS :
3294 SDValue(CurDAG->getMachineNode(PPC::XOR8, dl, MVT::i64, LHS, RHS), 0);
3295 SDValue AC =
3296 SDValue(CurDAG->getMachineNode(PPC::ADDIC8, dl, MVT::i64, MVT::Glue,
3298 return SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64, AC,
3320 SDValue ShiftL =
3321 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, LHS,
3324 SDValue ShiftR =
3325 SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, RHS,
3327 SDValue SubtractCarry =
3328 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3330 return SDValue(CurDAG->getMachineNode(PPC::ADDE8, dl, MVT::i64, MVT::Glue,
3341 SDValue Addi =
3342 SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, LHS,
3344 SDValue Nor =
3345 SDValue(CurDAG->getMachineNode(PPC::NOR8, dl, MVT::i64, Addi, LHS), 0);
3346 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, Nor,
3364 return SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, LHS,
3367 SDValue SRADINode =
3368 SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64,
3370 SDValue SRDINode =
3371 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3374 SDValue SUBFC8Carry =
3375 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3377 SDValue ADDE8Node =
3378 SDValue(CurDAG->getMachineNode(PPC::ADDE8, dl, MVT::i64, MVT::Glue,
3380 return SDValue(CurDAG->getMachineNode(PPC::XORI8, dl, MVT::i64,
3391 SDValue SUBFC8Carry =
3392 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3394 SDValue SUBFE8Node =
3395 SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64, MVT::Glue,
3397 return SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64,
3408 SDValue SubtractCarry =
3409 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3411 SDValue ExtSub =
3412 SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64,
3414 return SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64,
3422 SDValue
3423 IntegerCompareEliminator::get64BitSExtCompare(SDValue LHS, SDValue RHS,
3428 return SDValue();
3433 default: return SDValue();
3439 SDValue AddInput = IsRHSZero ? LHS :
3440 SDValue(CurDAG->getMachineNode(PPC::XOR8, dl, MVT::i64, LHS, RHS), 0);
3441 SDValue Addic =
3442 SDValue(CurDAG->getMachineNode(PPC::ADDIC8, dl, MVT::i64, MVT::Glue,
3444 return SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64, Addic,
3452 SDValue Xor = IsRHSZero ? LHS :
3453 SDValue(CurDAG->getMachineNode(PPC::XOR8, dl, MVT::i64, LHS, RHS), 0);
3454 SDValue SC =
3455 SDValue(CurDAG->getMachineNode(PPC::SUBFIC8, dl, MVT::i64, MVT::Glue,
3457 return SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64, SC,
3479 SDValue ShiftR =
3480 SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, RHS,
3482 SDValue ShiftL =
3483 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64, LHS,
3486 SDValue SubtractCarry =
3487 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3489 SDValue Adde =
3490 SDValue(CurDAG->getMachineNode(PPC::ADDE8, dl, MVT::i64, MVT::Glue,
3492 return SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64, Adde), 0);
3502 SDValue Add =
3503 SDValue(CurDAG->getMachineNode(PPC::ADDI8, dl, MVT::i64, LHS,
3505 SDValue Nor =
3506 SDValue(CurDAG->getMachineNode(PPC::NOR8, dl, MVT::i64, Add, LHS), 0);
3507 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, Nor,
3524 return SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, LHS,
3527 SDValue SRADINode =
3528 SDValue(CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64,
3530 SDValue SRDINode =
3531 SDValue(CurDAG->getMachineNode(PPC::RLDICL, dl, MVT::i64,
3534 SDValue SUBFC8Carry =
3535 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3537 SDValue ADDE8Node =
3538 SDValue(CurDAG->getMachineNode(PPC::ADDE8, dl, MVT::i64,
3540 SDValue XORI8Node =
3541 SDValue(CurDAG->getMachineNode(PPC::XORI8, dl, MVT::i64,
3543 return SDValue(CurDAG->getMachineNode(PPC::NEG8, dl, MVT::i64,
3554 SDValue SubtractCarry =
3555 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3557 SDValue ExtSub =
3558 SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64, MVT::Glue, LHS,
3560 return SDValue(CurDAG->getMachineNode(PPC::NOR8, dl, MVT::i64,
3571 SDValue SubCarry =
3572 SDValue(CurDAG->getMachineNode(PPC::SUBFC8, dl, MVT::i64, MVT::Glue,
3574 return SDValue(CurDAG->getMachineNode(PPC::SUBFE8, dl, MVT::i64,
3580 /// Do all uses of this SDValue need the result in a GPR?
3584 static bool allUsesExtend(SDValue Compare, SelectionDAG *CurDAG) {
3608 SDValue IntegerCompareEliminator::getSETCCInGPR(SDValue Compare,
3617 return SDValue();
3619 SDValue LHS = Compare.getOperand(0);
3620 SDValue RHS = Compare.getOperand(1);
3628 return SDValue();
3710 SDValue PPCDAGToDAGISel::SelectCC(SDValue LHS, SDValue RHS, ISD::CondCode CC,
3721 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS,
3726 return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS,
3739 SDValue Xor(CurDAG->getMachineNode(PPC::XORIS, dl, MVT::i32, LHS,
3741 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, Xor,
3747 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS,
3753 return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS,
3765 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS,
3770 return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS,
3784 SDValue Xor(CurDAG->getMachineNode(PPC::XORIS8, dl, MVT::i64, LHS,
3786 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, Xor,
3794 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS,
3800 return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS,
3864 return SDValue(CurDAG->getMachineNode(Opc, dl, MVT::i32, LHS, RHS), 0);
4061 SDValue Op = N->getOperand(0);
4065 Op = SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Op), 0);
4066 SDValue Ops[] = { Op, getI32Imm(27, dl), getI32Imm(5, dl),
4073 SDValue AD =
4074 SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4080 SDValue Ops[] = { Op, getI32Imm(1, dl), getI32Imm(31, dl),
4086 SDValue T =
4087 SDValue(CurDAG->getMachineNode(PPC::NEG, dl, MVT::i32, Op), 0);
4088 T = SDValue(CurDAG->getMachineNode(PPC::ANDC, dl, MVT::i32, T, Op), 0);
4089 SDValue Ops[] = { T, getI32Imm(1, dl), getI32Imm(31, dl),
4096 SDValue Op = N->getOperand(0);
4101 Op = SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4104 SDValue(CurDAG->getMachineNode(PPC::LI, dl,
4111 Op = SDValue(CurDAG->getMachineNode(PPC::NOR, dl, MVT::i32, Op, Op), 0);
4114 CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(AD, 0), Op,
4115 SDValue(AD, 1));
4119 SDValue AD = SDValue(CurDAG->getMachineNode(PPC::ADDI, dl, MVT::i32, Op,
4121 SDValue AN = SDValue(CurDAG->getMachineNode(PPC::AND, dl, MVT::i32, AD,
4123 SDValue Ops[] = { AN, getI32Imm(1, dl), getI32Imm(31, dl),
4129 SDValue Ops[] = { Op, getI32Imm(1, dl), getI32Imm(31, dl),
4131 Op = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops), 0);
4139 SDValue LHS = N->getOperand(0);
4140 SDValue RHS = N->getOperand(1);
4157 SDValue VCmp(CurDAG->getMachineNode(VCmpInst, dl, ResVT, LHS, RHS), 0);
4172 SDValue CCReg = SelectCC(LHS, RHS, CC, dl);
4173 SDValue IntCR;
4182 SDValue CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32);
4184 SDValue InFlag(nullptr, 0); // Null incoming flag value.
4188 IntCR = SDValue(CurDAG->getMachineNode(PPC::MFOCRF, dl, MVT::i32, CR7Reg,
4191 SDValue Ops[] = { IntCR, getI32Imm((32 - (3 - Idx)) & 31, dl),
4199 SDValue Tmp =
4200 SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops), 0);
4210 SDValue AddrOp;
4253 SDValue LHS = N->getOperand(0);
4254 SDValue RHS = N->getOperand(1);
4255 SDValue TrueRes = N->getOperand(2);
4256 SDValue FalseRes = N->getOperand(3);
4276 SDValue SetOrSelCC = InnerIsSel ? FalseRes : FalseRes.getOperand(0);
4292 SDValue InnerLHS = SetOrSelCC.getOperand(0);
4293 SDValue InnerRHS = SetOrSelCC.getOperand(1);
4392 SDValue Val = N->getOperand(0);
4398 SDValue Ops[] = {Val, getI32Imm(SH, dl), getI32Imm(MB, dl),
4407 SDValue Ops[] = {Val, getI32Imm(0, dl), getI32Imm(MB, dl),
4415 ReplaceUses(SDValue(N, 0), N->getOperand(1));
4439 SDValue Ops[] = {N->getOperand(0), getI64Imm(0, dl), getI64Imm(MB - 32, dl),
4460 SDValue Val = N->getOperand(0);
4485 Val = SDValue(CurDAG->getMachineNode(PPC::RLDICL, Loc, MVT::i64, Val,
4496 SDValue Ops[] = {Val, getI64Imm(64 - OnesOnLeft, Loc),
4508 SDValue Val = N->getOperand(0);
4531 SDValue Ops[] = {Val.getOperand(0), Val.getOperand(1), getI32Imm(0, dl),
4550 SDValue Val = N->getOperand(0);
4560 SDValue IDVal(ImDef, 0);
4562 Val = SDValue(CurDAG->getMachineNode(PPC::INSERT_SUBREG, dl, ResultType,
4582 SDValue Ops[] = {Val, getI32Imm(SH, dl), getI32Imm(MB, dl)};
4600 SDValue Ops[] = {N->getOperand(0), getI32Imm(SH, dl), getI32Imm(MB, dl)};
4609 SDValue N0 = N->getOperand(0);
4622 SDValue Ops[] = {
4624 SDValue(selectI64Imm(CurDAG, getI64Imm(-1, Dl).getNode()), 0),
4687 SDValue Op = N->getOperand(1);
4709 SDValue InFlag = N->getOperand(1);
4721 SDValue N0 = N->getOperand(0);
4722 SDValue ShiftAmt =
4730 CurDAG->SelectNodeTo(N, PPC::ADDZE8, MVT::i64, SDValue(Op, 0),
4731 SDValue(Op, 1));
4739 CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, SDValue(Op, 0),
4740 SDValue(Op, 1));
4768 SDValue Offset = LD->getOffset();
4799 SDValue Chain = LD->getChain();
4800 SDValue Base = LD->getBasePtr();
4801 SDValue Ops[] = { Offset, Base, Chain };
4839 SDValue Chain = LD->getChain();
4840 SDValue Base = LD->getBasePtr();
4841 SDValue Ops[] = { Base, Offset, Chain };
4895 SDValue Ops1[] = { SDValue(Lo, 0), getI16Imm(ImmHi, dl)};
4918 SDValue Ops1[] = { SDValue(Lo, 0), getI16Imm(ImmHi, dl)};
4940 SDValue Ops[] = { N->getOperand(0).getOperand(0),
4954 SDValue Ops[] = { N->getOperand(0).getOperand(0),
4975 SDValue AndI(CurDAG->getMachineNode(Opcode, dl, InVT, MVT::Glue,
4979 SDValue CR0Reg = CurDAG->getRegister(PPC::CR0, MVT::i32);
4980 SDValue SRIdxVal = CurDAG->getTargetConstant(
4985 SRIdxVal, SDValue(AndI.getNode(), 1) /* glue */);
5002 SDValue LHS = N->getOperand(0);
5003 SDValue RHS = N->getOperand(1);
5013 SDValue GenCC =
5035 CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(Tmp, 0),
5036 N->getOperand(0), SDValue(Tmp, 1));
5040 SDValue CCReg = SelectCC(N->getOperand(0), N->getOperand(1), CC, dl);
5056 SDValue CCBit = CurDAG->getTargetExtractSubreg(SRI, dl, MVT::i1, CCReg);
5058 SDValue NotCCBit(CurDAG->getMachineNode(PPC::CRNOR, dl, MVT::i1,
5060 SDValue C = Inv ? NotCCBit : CCBit,
5063 SDValue CAndT(CurDAG->getMachineNode(PPC::CRAND, dl, MVT::i1,
5065 SDValue NotCAndF(CurDAG->getMachineNode(PPC::CRAND, dl, MVT::i1,
5110 SDValue Ops[] = { CCReg, N->getOperand(2), N->getOperand(3),
5120 SDValue Op1 = N->getOperand(SVN->getMaskElt(0) < 2 ? 0 : 1),
5134 SDValue Base, Offset;
5140 SDValue Chain = LD->getChain();
5141 SDValue Ops[] = { Base, Offset, Chain };
5159 SDValue DMV = CurDAG->getTargetConstant(DM[1] | (DM[0] << 1), dl,
5161 SDValue Ops[] = { Op1, Op2, DMV };
5170 SDValue Ops[] = { N->getOperand(1), N->getOperand(0) };
5188 SDValue Pred = getI32Imm(PCC, dl);
5189 SDValue Ops[] = { Pred, N->getOperand(2), N->getOperand(3),
5221 SDValue BitComp(CurDAG->getMachineNode(Opc, dl, MVT::i1,
5232 SDValue CondCode = SelectCC(N->getOperand(2), N->getOperand(3), CC, dl);
5233 SDValue Ops[] = { getI32Imm(PCC, dl), CondCode,
5240 SDValue Chain = N->getOperand(0);
5241 SDValue Target = N->getOperand(1);
5244 Chain = SDValue(CurDAG->getMachineNode(Opc, dl, MVT::Glue, Target,
5271 SDValue GA = TocEntry->getOperand(0);
5272 SDValue TocBase = TocEntry->getOperand(1);
5310 SDValue GA = N->getOperand(0);
5311 SDValue TOCbase = N->getOperand(1);
5321 isPPC64 ? PPC::LDtocL : PPC::LWZtocL, dl, VT, GA, SDValue(Tmp, 0));
5330 SDValue(Tmp, 0), GA));
5379 SDValue EltVal = getI32Imm(Elt >> 1, dl);
5381 SDValue TmpVal = SDValue(Tmp, 0);
5391 SDValue EltVal = getI32Imm(Elt - 16, dl);
5395 ReplaceNode(N, CurDAG->getMachineNode(Opc3, dl, VT, SDValue(Tmp1, 0),
5396 SDValue(Tmp2, 0)));
5405 SDValue EltVal = getI32Imm(Elt + 16, dl);
5409 ReplaceNode(N, CurDAG->getMachineNode(Opc2, dl, VT, SDValue(Tmp1, 0),
5410 SDValue(Tmp2, 0)));
5425 SDValue PPCDAGToDAGISel::combineToCMPB(SDNode *N) {
5431 SDValue Res;
5441 SDValue RHS, LHS;
5445 auto IsByteSelectCC = [this](SDValue O, unsigned &b,
5447 SDValue &LHS, SDValue &RHS) {
5471 SDValue Op0 = O.getOperand(0), Op1 = O.getOperand(1);
5525 SDValue Op = O.getOperand(0);
5532 SDValue XOR = Op.getOperand(0);
5550 SDValue XOR = Op.getOperand(0);
5564 SmallVector<SDValue, 8> Queue(1, SDValue(N, 0));
5566 SDValue V = Queue.pop_back_val();
5568 for (const SDValue &O : V.getNode()->ops()) {
5571 SDValue OLHS, ORHS;
5642 void PPCDAGToDAGISel::foldBoolExts(SDValue &Res, SDNode *&N) {
5659 SDValue Cond = N->getOperand(0);
5660 SDValue ConstTrue =
5662 SDValue ConstFalse = CurDAG->getConstant(0, dl, VT);
5669 auto TryFold = [this, N, User, dl](SDValue Val) {
5670 SDValue UserO0 = User->getOperand(0), UserO1 = User->getOperand(1);
5671 SDValue O0 = UserO0.getNode() == N ? Val : UserO0;
5672 SDValue O1 = UserO1.getNode() == N ? Val : UserO1;
5680 SDValue TrueRes = TryFold(ConstTrue);
5683 SDValue FalseRes = TryFold(ConstFalse);
5712 SDValue Res;
5730 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
5841 SDValue Op = MachineNode->getOperand(1);
5868 SDValue Op = MachineNode->getOperand(0);
6240 static bool PeepholePPC64ZExtGather(SDValue Op32,
6412 SDValue ISR = N->getOperand(0);
6423 SDValue IDef = ISR.getOperand(0);
6431 SDValue Op32 = ISR->getOperand(1);
6499 SmallVector<SDValue, 4> Ops;
6500 for (const SDValue &V : PN->ops()) {
6503 SDValue ReplOpOps[] = { ISR.getOperand(0), V, ISR.getOperand(2) };
6507 Ops.push_back(SDValue(ReplOp, 0));
6611 SDValue Base = N->getOperand(FirstOp + 1);
6656 SDValue ImmOpnd = Base.getOperand(1);
6670 SDValue HBase = Base.getOperand(0);
6688 SDValue HImmOpnd = HBase.getOperand(1);