Lines Matching refs:Res
37 SDValue Res = SDValue();
50 case ISD::MERGE_VALUES:Res = PromoteIntRes_MERGE_VALUES(N, ResNo); break;
51 case ISD::AssertSext: Res = PromoteIntRes_AssertSext(N); break;
52 case ISD::AssertZext: Res = PromoteIntRes_AssertZext(N); break;
53 case ISD::BITCAST: Res = PromoteIntRes_BITCAST(N); break;
54 case ISD::BSWAP: Res = PromoteIntRes_BSWAP(N); break;
55 case ISD::BUILD_PAIR: Res = PromoteIntRes_BUILD_PAIR(N); break;
56 case ISD::Constant: Res = PromoteIntRes_Constant(N); break;
58 Res = PromoteIntRes_CONVERT_RNDSAT(N); break;
60 case ISD::CTLZ: Res = PromoteIntRes_CTLZ(N); break;
61 case ISD::CTPOP: Res = PromoteIntRes_CTPOP(N); break;
63 case ISD::CTTZ: Res = PromoteIntRes_CTTZ(N); break;
65 Res = PromoteIntRes_EXTRACT_VECTOR_ELT(N); break;
66 case ISD::LOAD: Res = PromoteIntRes_LOAD(cast<LoadSDNode>(N));break;
67 case ISD::SELECT: Res = PromoteIntRes_SELECT(N); break;
68 case ISD::VSELECT: Res = PromoteIntRes_VSELECT(N); break;
69 case ISD::SELECT_CC: Res = PromoteIntRes_SELECT_CC(N); break;
70 case ISD::SETCC: Res = PromoteIntRes_SETCC(N); break;
71 case ISD::SHL: Res = PromoteIntRes_SHL(N); break;
73 Res = PromoteIntRes_SIGN_EXTEND_INREG(N); break;
74 case ISD::SRA: Res = PromoteIntRes_SRA(N); break;
75 case ISD::SRL: Res = PromoteIntRes_SRL(N); break;
76 case ISD::TRUNCATE: Res = PromoteIntRes_TRUNCATE(N); break;
77 case ISD::UNDEF: Res = PromoteIntRes_UNDEF(N); break;
78 case ISD::VAARG: Res = PromoteIntRes_VAARG(N); break;
81 Res = PromoteIntRes_EXTRACT_SUBVECTOR(N); break;
83 Res = PromoteIntRes_VECTOR_SHUFFLE(N); break;
85 Res = PromoteIntRes_INSERT_VECTOR_ELT(N); break;
87 Res = PromoteIntRes_BUILD_VECTOR(N); break;
89 Res = PromoteIntRes_SCALAR_TO_VECTOR(N); break;
91 Res = PromoteIntRes_CONCAT_VECTORS(N); break;
95 case ISD::ANY_EXTEND: Res = PromoteIntRes_INT_EXTEND(N); break;
98 case ISD::FP_TO_UINT: Res = PromoteIntRes_FP_TO_XINT(N); break;
100 case ISD::FP32_TO_FP16:Res = PromoteIntRes_FP32_TO_FP16(N); break;
107 case ISD::MUL: Res = PromoteIntRes_SimpleIntBinOp(N); break;
110 case ISD::SREM: Res = PromoteIntRes_SDIV(N); break;
113 case ISD::UREM: Res = PromoteIntRes_UDIV(N); break;
116 case ISD::SSUBO: Res = PromoteIntRes_SADDSUBO(N, ResNo); break;
118 case ISD::USUBO: Res = PromoteIntRes_UADDSUBO(N, ResNo); break;
120 case ISD::UMULO: Res = PromoteIntRes_XMULO(N, ResNo); break;
123 Res = PromoteIntRes_Atomic0(cast<AtomicSDNode>(N)); break;
136 Res = PromoteIntRes_Atomic1(cast<AtomicSDNode>(N)); break;
139 Res = PromoteIntRes_Atomic2(cast<AtomicSDNode>(N)); break;
143 if (Res.getNode())
144 SetPromotedInteger(SDValue(N, ResNo), Res);
169 SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
176 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
177 return Res;
182 SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
189 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
190 return Res;
196 SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
202 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
203 return Res;
365 SDValue Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
371 ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
379 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
382 NVT, Res, DAG.getValueType(N->getValueType(0)));
391 SDValue Res = GetPromotedInteger(N->getOperand(0));
392 assert(Res.getValueType().bitsLE(NVT) && "Extension doesn't make sense!");
396 if (NVT == Res.getValueType()) {
399 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
402 return DAG.getZeroExtendInReg(Res, dl,
405 return Res;
419 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
424 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
425 return Res;
434 SDValue Res = DAG.getNode(N->getOpcode(), SDLoc(N),
439 ReplaceValueWith(SDValue(N, 0), Res);
441 return SDValue(Res.getNode(), 1);
458 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
462 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
464 // Overflowed if and only if this is not equal to Res.
465 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
470 return Res;
543 SDValue Res = GetPromotedInteger(N->getOperand(0));
546 return DAG.getNode(ISD::SHL, SDLoc(N), Res.getValueType(), Res, Amt);
567 SDValue Res = SExtPromotedInteger(N->getOperand(0));
570 return DAG.getNode(ISD::SRA, SDLoc(N), Res.getValueType(), Res, Amt);
575 SDValue Res = ZExtPromotedInteger(N->getOperand(0));
578 return DAG.getNode(ISD::SRL, SDLoc(N), Res.getValueType(), Res, Amt);
583 SDValue Res;
591 Res = InOp;
594 Res = GetPromotedInteger(InOp);
617 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
634 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
638 SDValue Ofl = DAG.getZeroExtendInReg(Res, dl, OVT);
639 // Overflowed if and only if this is not equal to Res.
640 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
645 return Res;
734 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
741 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
748 return Res;
761 SDValue Res = SDValue();
774 case ISD::ANY_EXTEND: Res = PromoteIntOp_ANY_EXTEND(N); break;
776 Res = PromoteIntOp_ATOMIC_STORE(cast<AtomicSDNode>(N));
778 case ISD::BITCAST: Res = PromoteIntOp_BITCAST(N); break;
779 case ISD::BR_CC: Res = PromoteIntOp_BR_CC(N, OpNo); break;
780 case ISD::BRCOND: Res = PromoteIntOp_BRCOND(N, OpNo); break;
781 case ISD::BUILD_PAIR: Res = PromoteIntOp_BUILD_PAIR(N); break;
782 case ISD::BUILD_VECTOR: Res = PromoteIntOp_BUILD_VECTOR(N); break;
783 case ISD::CONCAT_VECTORS: Res = PromoteIntOp_CONCAT_VECTORS(N); break;
784 case ISD::EXTRACT_VECTOR_ELT: Res = PromoteIntOp_EXTRACT_VECTOR_ELT(N); break;
786 Res = PromoteIntOp_CONVERT_RNDSAT(N); break;
788 Res = PromoteIntOp_INSERT_VECTOR_ELT(N, OpNo);break;
790 Res = PromoteIntOp_SCALAR_TO_VECTOR(N); break;
792 case ISD::SELECT: Res = PromoteIntOp_SELECT(N, OpNo); break;
793 case ISD::SELECT_CC: Res = PromoteIntOp_SELECT_CC(N, OpNo); break;
794 case ISD::SETCC: Res = PromoteIntOp_SETCC(N, OpNo); break;
795 case ISD::SIGN_EXTEND: Res = PromoteIntOp_SIGN_EXTEND(N); break;
796 case ISD::SINT_TO_FP: Res = PromoteIntOp_SINT_TO_FP(N); break;
797 case ISD::STORE: Res = PromoteIntOp_STORE(cast<StoreSDNode>(N),
799 case ISD::TRUNCATE: Res = PromoteIntOp_TRUNCATE(N); break;
801 case ISD::UINT_TO_FP: Res = PromoteIntOp_UINT_TO_FP(N); break;
802 case ISD::ZERO_EXTEND: Res = PromoteIntOp_ZERO_EXTEND(N); break;
808 case ISD::ROTR: Res = PromoteIntOp_Shift(N); break;
812 if (!Res.getNode()) return false;
816 if (Res.getNode() == N)
819 assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
822 ReplaceValueWith(SDValue(N, 0), Res);
1635 SDValue Res = DisintegrateMERGE_VALUES(N, ResNo);
1636 SplitInteger(Res, Lo, Hi);
1654 SDValue Res = GetPromotedInteger(Op);
1655 assert(Res.getValueType() == N->getValueType(0) &&
1658 SplitInteger(Res, Lo, Hi);
2193 SDValue Res = GetPromotedInteger(Op);
2194 assert(Res.getValueType() == N->getValueType(0) &&
2197 SplitInteger(Res, Lo, Hi);
2428 SDValue Res = GetPromotedInteger(Op);
2429 assert(Res.getValueType() == N->getValueType(0) &&
2432 SplitInteger(Res, Lo, Hi);
2466 SDValue Res = SDValue();
2479 case ISD::BITCAST: Res = ExpandOp_BITCAST(N); break;
2480 case ISD::BR_CC: Res = ExpandIntOp_BR_CC(N); break;
2481 case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break;
2482 case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break;
2483 case ISD::INSERT_VECTOR_ELT: Res = ExpandOp_INSERT_VECTOR_ELT(N); break;
2484 case ISD::SCALAR_TO_VECTOR: Res = ExpandOp_SCALAR_TO_VECTOR(N); break;
2485 case ISD::SELECT_CC: Res = ExpandIntOp_SELECT_CC(N); break;
2486 case ISD::SETCC: Res = ExpandIntOp_SETCC(N); break;
2487 case ISD::SINT_TO_FP: Res = ExpandIntOp_SINT_TO_FP(N); break;
2488 case ISD::STORE: Res = ExpandIntOp_STORE(cast<StoreSDNode>(N), OpNo); break;
2489 case ISD::TRUNCATE: Res = ExpandIntOp_TRUNCATE(N); break;
2490 case ISD::UINT_TO_FP: Res = ExpandIntOp_UINT_TO_FP(N); break;
2496 case ISD::ROTR: Res = ExpandIntOp_Shift(N); break;
2498 case ISD::FRAMEADDR: Res = ExpandIntOp_RETURNADDR(N); break;
2500 case ISD::ATOMIC_STORE: Res = ExpandIntOp_ATOMIC_STORE(N); break;
2504 if (!Res.getNode()) return false;
2508 if (Res.getNode() == N)
2511 assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
2514 ReplaceValueWith(SDValue(N, 0), Res);