Lines Matching defs:Ld
2648 auto *Ld = cast<LoadSDNode>(Op.getNode());
2650 Ld->getValueSizeInBits(0) == 128 && Ld->getAlign() < Align(16))
2668 auto *Ld = cast<LoadSDNode>(Op.getNode());
2669 return !Ld->isVolatile() ||
2670 Ld->getValueSizeInBits(0) == EltVT.getScalarSizeInBits();
6849 static bool findEltLoadSrc(SDValue Elt, LoadSDNode *&Ld, int64_t &ByteOffset) {
6854 Ld = BaseLd;
6863 return findEltLoadSrc(Elt.getOperand(0), Ld, ByteOffset);
6867 if ((Amt % 8) == 0 && findEltLoadSrc(Elt.getOperand(0), Ld, ByteOffset)) {
6879 findEltLoadSrc(Src, Ld, ByteOffset)) {
6975 LoadSDNode *Ld = Loads[EltIdx];
6980 Loads[BaseIdx] == Ld && ByteOffsets[BaseIdx] == 0);
6982 return DAG.areNonVolatileConsecutiveLoads(Ld, Base, BaseSizeInBytes,
7295 SDValue Ld;
7301 Ld = Sequence[0];
7342 if (!Ld || (NumElts - NumUndefElts) <= 1) {
7392 // If we are moving a scalar into a vector (Ld must be set and all elements
7397 if (!Ld || NumElts - NumUndefElts != 1)
7399 unsigned ScalarSize = Ld.getValueSizeInBits();
7405 (Ld.getOpcode() == ISD::Constant || Ld.getOpcode() == ISD::ConstantFP);
7406 bool IsLoad = ISD::isNormalLoad(Ld.getNode());
7413 if (!ConstSplatVal && !IsLoad && !BVOp->isOnlyUserOf(Ld.getNode()))
7416 unsigned ScalarSize = Ld.getValueSizeInBits();
7433 EVT CVT = Ld.getValueType();
7445 if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
7447 else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
7468 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
7475 if (!Ld->hasNUsesOfValue(NumElts - NumUndefElts, 0))
7480 auto *LN = cast<LoadSDNode>(Ld);
7492 if (Subtarget.hasInt256() && Ld.getValueType().isInteger() &&
7494 auto *LN = cast<LoadSDNode>(Ld);
7505 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
8940 SDValue Ld = DAG.getLoad(VT, dl, DAG.getEntryNode(), LegalDAGConstVec, MPI);
8944 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Ld, VarElt, InsIndex);
8955 return DAG.getVectorShuffle(VT, dl, Ld, S2V, ShuffleMask);
12589 LoadSDNode *Ld = cast<LoadSDNode>(V);
12590 SDValue BaseAddr = Ld->getOperand(1);
12602 SDValue Ops[] = {Ld->getChain(), NewAddr};
12606 Ld->getMemOperand(), Offset, SVT.getStoreSize()));
12607 DAG.makeEquivalentMemoryOrdering(Ld, V);
12611 V = DAG.getLoad(SVT, DL, Ld->getChain(), NewAddr,
12613 Ld->getMemOperand(), Offset, SVT.getStoreSize()));
12614 DAG.makeEquivalentMemoryOrdering(Ld, V);
14953 auto *Ld = cast<LoadSDNode>(peekThroughOneUseBitcasts(V1));
14955 VT, MemVT, Ld, Ofs, DAG))
24762 LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
24763 SDLoc dl(Ld);
24767 assert(EVT(RegVT) == Ld->getMemoryVT() && "Expected non-extending load");
24772 SDValue NewLd = DAG.getLoad(MVT::i8, dl, Ld->getChain(), Ld->getBasePtr(),
24773 Ld->getPointerInfo(), Ld->getOriginalAlign(),
24774 Ld->getMemOperand()->getFlags());
33439 SDValue Ld = DAG.getLoad(MVT::v2i64, dl, Node->getChain(),
33441 SDValue ResL = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Ld,
33443 SDValue ResH = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Ld,
33447 Results.push_back(Ld.getValue(1));
33458 SDValue Ld = DAG.getMemIntrinsicNode(X86ISD::VZEXT_LOAD, dl, Tys, Ops,
33461 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Ld,
33464 Results.push_back(Ld.getValue(1));
33470 SDValue Res = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2f32, Ld,
33474 Results.push_back(Ld.getValue(1));
33606 auto *Ld = cast<LoadSDNode>(N);
33609 SDValue Res = DAG.getLoad(LdVT, dl, Ld->getChain(), Ld->getBasePtr(),
33610 Ld->getPointerInfo(), Ld->getOriginalAlign(),
33611 Ld->getMemOperand()->getFlags());
33623 SDValue Ops[] = {Ld->getChain(), Ld->getBasePtr()};
33625 MVT::i64, Ld->getMemOperand());
42427 SDValue Ld =
42431 Ld.getValue(1));
42432 return TLO.CombineTo(Op, insertSubVector(TLO.DAG.getUNDEF(VT), Ld, 0,
49450 static SDValue getIndexFromUnindexedLoad(LoadSDNode *Ld) {
49451 if (Ld->isIndexed())
49454 SDValue Base = Ld->getBasePtr();
49495 LoadSDNode *Ld = dyn_cast<LoadSDNode>(N.getNode());
49498 if (!Ld)
49501 const Value *MemOp = Ld->getMemOperand()->getValue();
49541 SDValue Index = getIndexFromUnindexedLoad(Ld);
51141 auto *Ld = cast<LoadSDNode>(N);
51142 EVT RegVT = Ld->getValueType(0);
51143 SDValue Ptr = Ld->getBasePtr();
51144 SDValue Chain = Ld->getChain();
51145 ISD::LoadExtType Ext = Ld->getExtensionType();
51147 if (Ext != ISD::NON_EXTLOAD || !Subtarget.hasAVX() || !Ld->isSimple())
51215 auto *Ld = cast<LoadSDNode>(N);
51216 EVT RegVT = Ld->getValueType(0);
51217 EVT MemVT = Ld->getMemoryVT();
51218 SDLoc dl(Ld);
51224 ISD::LoadExtType Ext = Ld->getExtensionType();
51228 ((Ld->isNonTemporal() && !Subtarget.hasInt256() &&
51229 Ld->getAlign() >= Align(16)) ||
51231 *Ld->getMemOperand(), &Fast) &&
51238 SDValue Ptr1 = Ld->getBasePtr();
51244 DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr1, Ld->getPointerInfo(),
51245 Ld->getOriginalAlign(),
51246 Ld->getMemOperand()->getFlags());
51247 SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr2,
51248 Ld->getPointerInfo().getWithOffset(HalfOffset),
51249 Ld->getOriginalAlign(),
51250 Ld->getMemOperand()->getFlags());
51265 SDValue IntLoad = DAG.getLoad(IntVT, dl, Ld->getChain(), Ld->getBasePtr(),
51266 Ld->getPointerInfo(),
51267 Ld->getOriginalAlign(),
51268 Ld->getMemOperand()->getFlags());
51276 if (Ext == ISD::NON_EXTLOAD && Subtarget.hasAVX() && Ld->isSimple() &&
51278 SDValue Ptr = Ld->getBasePtr();
51279 SDValue Chain = Ld->getChain();
51297 if (SDValue V = combineConstantPoolLoads(Ld, dl, DAG, DCI, Subtarget))
51301 unsigned AddrSpace = Ld->getAddressSpace();
51305 if (PtrVT != Ld->getBasePtr().getSimpleValueType()) {
51307 DAG.getAddrSpaceCast(dl, PtrVT, Ld->getBasePtr(), AddrSpace, 0);
51308 return DAG.getExtLoad(Ext, dl, RegVT, Ld->getChain(), Cast,
51309 Ld->getPointerInfo(), MemVT, Ld->getOriginalAlign(),
51310 Ld->getMemOperand()->getFlags());
51829 auto *Ld = cast<LoadSDNode>(St->getValue());
51831 if (!ISD::isNormalLoad(Ld))
51835 if (!Ld->hasNUsesOfValue(1, 0))
51838 SDLoc LdDL(Ld);
51841 SDValue NewLd = DAG.getLoad(MVT::f64, LdDL, Ld->getChain(),
51842 Ld->getBasePtr(), Ld->getMemOperand());
51845 DAG.makeEquivalentMemoryOrdering(Ld, NewLd);
55055 LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
55066 if (Ld->isSimple() && !VT.isVector() && ISD::isNormalLoad(Op0.getNode()) &&
55070 VT, InVT, SDLoc(N), Ld->getChain(), Ld->getBasePtr(),
55071 Ld->getPointerInfo(), Ld->getOriginalAlign(), DAG);
56671 if (SDValue Ld =
56673 return Ld;
56697 SDValue Ld = DAG.getLoad(VT, DL, DAG.getEntryNode(), CV, MPI);
56698 SDValue Sub = extractSubVector(Ld, 0, DAG, DL, Op0.getValueSizeInBits());
56700 return Ld;
57233 if (auto *Ld = dyn_cast<LoadSDNode>(Op))
57234 if (Ld->getExtensionType() == Ext &&
57235 Ld->getMemoryVT().getScalarSizeInBits() <= 32)
57395 auto *Ld = cast<LoadSDNode>(In);
57396 if (Ld->isSimple()) {
57404 Ext, DL, VT, Ld->getChain(), Ld->getBasePtr(), Ld->getPointerInfo(),
57405 MemVT, Ld->getOriginalAlign(), Ld->getMemOperand()->getFlags());
57406 DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
58060 auto *Ld = cast<LoadSDNode>(Load);
58062 return Ld->getBasePtr() == St->getBasePtr();
58073 auto *Ld = cast<AtomicSDNode>(Load);
58075 return Ld->getBasePtr() == St->getBasePtr();