Lines Matching refs:SDValue
68 SDValue Chain = LD->getChain();
69 SDValue Base = LD->getBasePtr();
70 SDValue Offset = LD->getOffset();
129 SDValue IncV = CurDAG->getTargetConstant(Inc, dl, MVT::i32);
135 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
137 Zero, SDValue(N, 0));
141 SDValue(N, 0));
146 SDValue From[3] = { SDValue(LD,0), SDValue(LD,1), SDValue(LD,2) };
147 SDValue To[3];
162 To[1] = SDValue(L, 1); // Next address.
163 To[2] = SDValue(L, 2); // Chain.
167 To[0] = SDValue(L, 0); // Loaded (extended) value.
169 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
173 To[2] = SDValue(L, 1); // Chain.
176 To[1] = SDValue(A, 0); // Next address.
180 To[0] = SDValue(L, 0); // Loaded (extended) value.
207 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), dl, MVT::i32);
229 SDValue TS;
230 SDValue Loc = IntN->getOperand(3);
233 TS = CurDAG->getStore(SDValue(LoadN, 2), dl, SDValue(LoadN, 0), Loc, PI,
236 TS = CurDAG->getTruncStore(SDValue(LoadN, 2), dl, SDValue(LoadN, 0), Loc,
247 ReplaceUses(SDValue(IntN, 0), SDValue(LoadN, 1));
248 ReplaceUses(SDValue(IntN, 1), SDValue(StoreN, 0));
266 SDValue Ch = N->getOperand(0);
267 SDValue Loc = N->getOperand(1);
306 SDValue F[] = { SDValue(N,0), SDValue(N,1), SDValue(C,0), SDValue(C,1) };
307 SDValue T[] = { SDValue(L,0), SDValue(S,0), SDValue(L,1), SDValue(S,0) };
349 ReplaceUses(SDValue(IntN, 0), SDValue(Res, 0));
350 ReplaceUses(SDValue(IntN, 1), SDValue(Res, 1));
351 ReplaceUses(SDValue(IntN, 2), SDValue(Res, 2));
366 SmallVector<SDValue, 7> Ops;
392 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), DL, MVT::i32);
402 ReplaceUses(SDValue(IntN, 0), SDValue(Res, 0));
403 ReplaceUses(SDValue(IntN, 1), SDValue(Res, 1));
404 ReplaceUses(SDValue(IntN, 2), SDValue(Res, 2));
427 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), DL, MVT::i32);
437 ReplaceUses(SDValue(IntN, 0), SDValue(Res, 0));
438 ReplaceUses(SDValue(IntN, 1), SDValue(Res, 1));
465 SDValue Chain = ST->getChain();
466 SDValue Base = ST->getBasePtr();
467 SDValue Offset = ST->getOffset();
468 SDValue Value = ST->getValue();
525 SDValue IncV = CurDAG->getTargetConstant(Inc, dl, MVT::i32);
529 SDValue From[2] = { SDValue(ST,0), SDValue(ST,1) };
530 SDValue To[2];
534 SDValue Ops[] = { Base, IncV, Value, Chain };
538 To[0] = SDValue(S, 0);
539 To[1] = SDValue(S, 1);
541 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
542 SDValue Ops[] = { Base, Zero, Value, Chain };
545 To[1] = SDValue(S, 0);
548 To[0] = SDValue(A, 0);
571 SDValue Shl_0 = N->getOperand(0);
572 SDValue Shl_1 = N->getOperand(1);
583 SDValue Mul_0 = Shl_0.getOperand(0); // Val
584 SDValue Mul_1 = Shl_0.getOperand(1); // Const
589 SDValue Val = CurDAG->getTargetConstant(ValConst, dl, MVT::i32);
600 SDValue Sub_0 = Shl_0.getOperand(0); // Const 0
601 SDValue Sub_1 = Shl_0.getOperand(1); // Val
605 SDValue Shl2_0 = Sub_1.getOperand(0); // Val
606 SDValue Shl2_1 = Sub_1.getOperand(1); // Const
610 SDValue Val = CurDAG->getTargetConstant(-ValConst, dl, MVT::i32);
684 SDValue V = N->getOperand(1);
685 SDValue U;
687 SDValue R = CurDAG->getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
704 SDValue V = CurDAG->getTargetConstant(A.getZExtValue(), dl, MVT::i32);
709 SDValue V = CurDAG->getTargetConstant(A.getZExtValue(), dl, MVT::i64);
739 SDValue FI = CurDAG->getTargetFrameIndex(FX, MVT::i32);
741 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
754 SDValue CH = CurDAG->getEntryNode();
755 SDValue Ops[] = { CurDAG->getCopyFromReg(CH, DL, AR, MVT::i32), FI, Zero };
779 SDValue Ops[] = {
791 SDValue M0 = CurDAG->getTargetConstant(0x18, dl, MVT::i32);
792 SDValue M1 = CurDAG->getTargetConstant(0x03, dl, MVT::i32);
800 SDValue(T, 0), M0);
803 SDValue(R, 0), SDValue(C, 0));
804 SDValue E = CurDAG->getTargetExtractSubreg(Hexagon::isub_lo, dl, ResTy,
805 SDValue(S, 0));
813 SDValue(Pu,0));
820 SDValue A = N->getOperand(1);
824 SDValue M = CurDAG->getTargetConstant(Mask, dl, MVT::i32);
834 SDValue Op = N->getOperand(0);
851 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
864 SDValue C = CurDAG->getTargetConstant(-1, dl, MVT::i32);
867 N->getOperand(0), SDValue(R,0));
877 SDValue C = CurDAG->getTargetConstant(-1, dl, MVT::i32);
880 N->getOperand(0), SDValue(R,0));
920 SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
921 std::vector<SDValue> &OutOps) {
922 SDValue Inp = Op, Res;
960 SDValue S0 = U->getOperand(0);
961 SDValue S1 = U->getOperand(1);
962 SDValue SY = (S0.getNode() == I) ? S1 : S0;
974 SDValue LDBasePtr = cast<MemSDNode>(SYNode)->getBasePtr();
975 SDValue STBasePtr = cast<MemSDNode>(UUse)->getBasePtr();
992 auto IsZero = [] (const SDValue &V) -> bool {
997 auto IsSelect0 = [IsZero] (const SDValue &Op) -> bool {
1003 SDValue N0 = I->getOperand(0), N1 = I->getOperand(1);
1006 SDValue SOp = SelN0 ? N0 : N1;
1007 SDValue VOp = SelN0 ? N1 : N0;
1010 SDValue SC = SOp.getOperand(0);
1011 SDValue SX = SOp.getOperand(1);
1012 SDValue SY = SOp.getOperand(2);
1015 SDValue NewOr = DAG.getNode(ISD::OR, DLS, VT, SX, VOp);
1016 SDValue NewSel = DAG.getNode(ISD::SELECT, DLS, VT, SC, NewOr, VOp);
1019 SDValue NewOr = DAG.getNode(ISD::OR, DLS, VT, SY, VOp);
1020 SDValue NewSel = DAG.getNode(ISD::SELECT, DLS, VT, SC, VOp, NewOr);
1041 SDValue Off = I->getOperand(2);
1046 SDValue T0 = Off.getOperand(1);
1051 SDValue T1 = T0.getOperand(0);
1052 SDValue T2 = T0.getOperand(1);
1056 SDValue C = T1.getOperand(1);
1075 SDValue D = DAG.getConstant(DV, DL, VT);
1077 SDValue NewAdd = DAG.getNode(ISD::ADD, DL, VT, T1.getOperand(0), D);
1079 SDValue NewShl = DAG.getNode(ISD::SHL, DL, VT, NewAdd, C);
1104 SDValue Addr = Opc == ISD::LOAD ? N->getOperand(1) : N->getOperand(2);
1108 SDValue T0 = Addr.getOperand(1);
1116 SDValue S = T0.getOperand(0);
1148 SDValue Y = S.getOperand(0);
1152 SDValue D = DAG.getConstant(TZ+CV, dl, VT);
1153 SDValue DC = DAG.getConstant(TZ, dl, VT);
1154 SDValue NewSrl = DAG.getNode(ISD::SRL, dl, VT, Y, D);
1155 SDValue NewShl = DAG.getNode(ISD::SHL, dl, VT, NewSrl, DC);
1169 SDValue OpI1 = N->getOperand(0);
1185 SmallVector<SDValue,2> Ops(U->getNumOperands());
1191 SDValue C0 = DAG.getConstant(0, dl, BVT);
1192 SDValue C1 = DAG.getConstant(1, dl, BVT);
1193 SDValue If0, If1;
1198 If0 = SDValue(DAG.getMachineNode(UseOpc, dl, UVT, Ops), 0);
1200 If1 = SDValue(DAG.getMachineNode(UseOpc, dl, UVT, Ops), 0);
1212 SDValue Sel = DAG.getNode(ISD::SELECT, dl, SVT, OpI1,
1215 SDValue Ret = DAG.getBitcast(UVT, Sel);
1305 bool HexagonDAGToDAGISel::SelectAddrFI(SDValue &N, SDValue &R) {
1317 inline bool HexagonDAGToDAGISel::SelectAddrGA(SDValue &N, SDValue &R) {
1321 inline bool HexagonDAGToDAGISel::SelectAddrGP(SDValue &N, SDValue &R) {
1325 inline bool HexagonDAGToDAGISel::SelectAnyImm(SDValue &N, SDValue &R) {
1329 inline bool HexagonDAGToDAGISel::SelectAnyImm0(SDValue &N, SDValue &R) {
1332 inline bool HexagonDAGToDAGISel::SelectAnyImm1(SDValue &N, SDValue &R) {
1335 inline bool HexagonDAGToDAGISel::SelectAnyImm2(SDValue &N, SDValue &R) {
1338 inline bool HexagonDAGToDAGISel::SelectAnyImm3(SDValue &N, SDValue &R) {
1342 inline bool HexagonDAGToDAGISel::SelectAnyInt(SDValue &N, SDValue &R) {
1350 bool HexagonDAGToDAGISel::SelectAnyImmediate(SDValue &N, SDValue &R,
1391 bool HexagonDAGToDAGISel::SelectGlobalAddress(SDValue &N, SDValue &R,
1395 SDValue N0 = N.getOperand(0);
1396 SDValue N1 = N.getOperand(1);
1405 SDValue Addr = N0.getOperand(0);
1436 bool HexagonDAGToDAGISel::DetectUseSxtw(SDValue &N, SDValue &R) {
1502 SDValue Ops[] = {
1509 R = SDValue(T, 0);
1513 bool HexagonDAGToDAGISel::keepsLowBits(const SDValue &Val, unsigned NumBits,
1514 SDValue &Src) {
1520 const SDValue &Op0 = Val.getOperand(0);
1652 SDValue Value;
1656 WeightedLeaf() : Value(SDValue()) { }
1658 WeightedLeaf(SDValue Value, int Weight, int InsertionOrder) :
1749 const SDValue &Val = L.Value;
1776 const SDValue &Val = L.Value;
1797 SDValue HexagonDAGToDAGISel::getMultiplierForSHL(SDNode *N) {
1804 static unsigned getPowerOf2Factor(SDValue Val) {
1827 static bool willShiftRightEliminate(SDValue V, unsigned Amount) {
1829 SDValue Ops[] = { V.getOperand(0), V.getOperand(1) };
1843 SDValue HexagonDAGToDAGISel::factorOutPowerOf2(SDValue V, unsigned Power) {
1844 SDValue Ops[] = { V.getOperand(0), V.getOperand(1) };
1868 static bool isTargetConstant(const SDValue &V) {
1893 /// @returns The SDValue taking the place of N (which could be N if it is
1895 SDValue HexagonDAGToDAGISel::balanceSubTree(SDNode *N, bool TopLevel) {
1902 return SDValue(N, 0);
1906 SDValue Op0 = N->getOperand(0);
1907 SDValue Op1 = N->getOperand(1);
1935 return SDValue(N, 0);
1944 SmallVector<SDValue, 4> Worklist;
1945 Worklist.push_back(SDValue(N, 0));
1969 SmallDenseMap<SDValue, int> NodeHeights;
1973 SDValue Child = Worklist.pop_back_val();
2035 SDValue Op1;
2058 LLVM_DEBUG(dbgs() << "--> Current height=" << NodeHeights[SDValue(N, 0)]
2069 SDValue Mul1Factored = factorOutPowerOf2(Mul1.Value, MaxPowerOf2);
2070 SDValue Mul2Factored = factorOutPowerOf2(Mul2.Value, MaxPowerOf2);
2071 SDValue Sum = CurDAG->getNode(ISD::ADD, SDLoc(N), Mul1.Value.getValueType(),
2073 SDValue Const = CurDAG->getConstant(MaxPowerOf2, SDLoc(N),
2075 SDValue New = CurDAG->getNode(ISD::SHL, SDLoc(N), Mul1.Value.getValueType(),
2104 SDValue NewTGA =
2122 RootHeights[N] = NodeHeights[SDValue(N, 0)];
2124 return SDValue(N, 0);
2165 SDValue V0 = L0.Value;
2167 SDValue V1 = L1.Value;
2180 SDValue NewNode;
2213 SDValue NewRoot = Leaves.top().Value;
2223 SDValue V0 = NewRoot.getOperand(0);
2256 SDValue BasePtr = cast<MemSDNode>(N)->getBasePtr();
2296 SDValue NewBasePtr = balanceSubTree(BasePtr.getNode(), /*TopLevel=*/ true);