Target/PowerPC/PPCISelLowering.cpp

2564   LoadSDNode *LD = dyn_cast<LoadSDNode>(N);
2565   if (!LD)
2568   EVT MemVT = LD->getMemoryVT();
2591   for (SDNode::use_iterator UI = LD->use_begin(), UE = LD->use_end();
2613   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
2614     Ptr = LD->getBasePtr();
2615     VT = LD->getMemoryVT();
2616     Alignment = LD->getAlignment();
2678   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(N)) {
2681     if (LD->getValueType(0) == MVT::i64 && LD->getMemoryVT() == MVT::i32 &&
2682         LD->getExtensionType() == ISD::SEXTLOAD &&
5164   // a static relocation model causes some versions of GNU LD (2.17.50, at
7476   LoadSDNode *LD = cast<LoadSDNode>(Op);
7478   SDValue Chain = LD->getChain();
7479   SDValue BasePtr = LD->getBasePtr();
7480   MachineMemOperand *MMO = LD->getMemOperand();
7883   LoadSDNode *LD = dyn_cast<LoadSDNode>(Op);
7884   if (!LD || LD->getExtensionType() != ET || LD->isVolatile() ||
7885       LD->isNonTemporal())
7887   if (LD->getMemoryVT() != MemVT)
7890   RLI.Ptr = LD->getBasePtr();
7891   if (LD->isIndexed() && !LD->getOffset().isUndef()) {
7892     assert(LD->getAddressingMode() == ISD::PRE_INC &&
7895                           LD->getOffset());
7898   RLI.Chain = LD->getChain();
7899   RLI.MPI = LD->getPointerInfo();
7900   RLI.IsDereferenceable = LD->isDereferenceable();
7901   RLI.IsInvariant = LD->isInvariant();
7902   RLI.Alignment = LD->getAlignment();
7903   RLI.AAInfo = LD->getAAInfo();
7904   RLI.Ranges = LD->getRanges();
7906   RLI.ResChain = SDValue(LD, LD->isIndexed() ? 2 : 1);
8613   LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
8614   return ISD::isNormalLoad(LD) ? InputLoad : nullptr;
8744       LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
8747       unsigned ElementSize = LD->getMemoryVT().getScalarSizeInBits();
8756           LD->getChain(),    // Chain
8757           LD->getBasePtr(),  // Ptr
8763                                   Ops, LD->getMemoryVT(), LD->getMemOperand());
9245     LoadSDNode *LD = cast<LoadSDNode>(*InputLoad);
9253       SDValue BasePtr = LD->getBasePtr();
9258         LD->getChain(),    // Chain
9266                                 Ops, LD->getMemoryVT(), LD->getMemOperand());
10428       LoadSDNode *LD = cast<LoadSDNode>(LdOp);
10429       SDValue LoadOps[] = {LD->getChain(), LD->getBasePtr()};
10432           LD->getMemoryVT(), LD->getMemOperand());
10441     LoadSDNode *LD = cast<LoadSDNode>(Op0);
10442     SDValue LoadOps[] = {LD->getChain(), LD->getBasePtr()};
10445         LD->getMemoryVT(), LD->getMemOperand());
11137     MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), FP)
11149     MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), Tmp)
11161     MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), SP)
11173     MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), BP)
11186     MIB = BuildMI(*MBB, MI, DL, TII->get(PPC::LD), PPC::X2)
11880           LoadOp = PPC::LD;
12218 static bool findConsecutiveLoad(LoadSDNode *LD, SelectionDAG &DAG) {
12219   SDValue Chain = LD->getChain();
12220   EVT VT = LD->getMemoryVT();
12235       if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
12266         if (isConsecutiveLS(ChainLD, LD, VT.getStoreSize(), 1, DAG))
12956   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Op.getNode()))
12957     return LD->getExtensionType() == ISD::EXTLOAD &&
13074     LoadSDNode *LD = dyn_cast<LoadSDNode>(FirstInput.getOperand(0));
13075     IsRoundOfExtLoad = LD->getExtensionType() == ISD::EXTLOAD;
13477     LoadSDNode *LD = cast<LoadSDNode>(N);
13478     Chain = LD->getChain();
13479     Base = LD->getBasePtr();
13480     MMO = LD->getMemOperand();
13848     LoadSDNode *LD = cast<LoadSDNode>(N);
13849     EVT VT = LD->getValueType(0);
13872       if (LD->getExtensionType() != ISD::NON_EXTLOAD ||
13873           LD->isVolatile())
13884       if (!LD->hasNUsesOfValue(2, 0))
13887       auto UI = LD->use_begin();
13927       SDValue BasePtr = LD->getBasePtr();
13928       if (LD->isIndexed()) {
13929         assert(LD->getAddressingMode() == ISD::PRE_INC &&
13933                       LD->getOffset());
13937           LD->getMemOperand()->getFlags() & ~MachineMemOperand::MOVolatile;
13938       SDValue FloatLoad = DAG.getLoad(MVT::f32, dl, LD->getChain(), BasePtr,
13939                                       LD->getPointerInfo(), LD->getAlignment(),
13940                                       MMOFlags, LD->getAAInfo());
13946           LD->getPointerInfo().getWithOffset(4),
13947           MinAlign(LD->getAlignment(), 4), MMOFlags, LD->getAAInfo());
13949       if (LD->isIndexed()) {
13952         DAG.ReplaceAllUsesOfValueWith(SDValue(LD, 1), BasePtr);
13958       DAG.ReplaceAllUsesOfValueWith(SDValue(LD, LD->isIndexed() ? 2 : 1),
13966     EVT MemVT = LD->getMemoryVT();
13971     if (LD->isUnindexed() && VT.isVector() &&
13977           LD->getAlignment() >= ScalarABIAlignment)) &&
13978         LD->getAlignment() < ABIAlignment) {
13980       SDValue Chain = LD->getChain();
13981       SDValue Ptr = LD->getBasePtr();
14038         MF.getMachineMemOperand(LD->getMemOperand(),
14065       if (!findConsecutiveLoad(LD, DAG))
14073         MF.getMachineMemOperand(LD->getMemOperand(),
14235       LoadSDNode *LD = cast<LoadSDNode>(Load);
14238         LD->getChain(),    // Chain
14239         LD->getBasePtr(),  // Ptr
14246                                 Ops, LD->getMemoryVT(), LD->getMemOperand());
15233   if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Val)) {
15234     EVT MemVT = LD->getMemoryVT();
15237         (LD->getExtensionType() == ISD::NON_EXTLOAD ||
15238          LD->getExtensionType() == ISD::ZEXTLOAD))