Target/X86/X86ISelLowering.cpp

3662   } else if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Arg)) {
3670     SDValue Ptr = Ld->getBasePtr();
5566   SDValue Ld;
5584       Ld = Splat;
5585       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5586                        Ld.getOpcode() == ISD::ConstantFP);
5590       if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
5616       Ld = Sc.getOperand(0);
5617       ConstSplatVal = (Ld.getOpcode() == ISD::Constant ||
5618                        Ld.getOpcode() == ISD::ConstantFP);
5626         Ld.getValueType().getSizeInBits() >= 32;
5627       if (!ConstSplatVal && ((!Sc.hasOneUse() || !Ld.hasOneUse()) &&
5634   unsigned ScalarSize = Ld.getValueType().getSizeInBits();
5651     EVT CVT = Ld.getValueType();
5661       if (ConstantSDNode *CI = dyn_cast<ConstantSDNode>(Ld))
5663       else if (ConstantFPSDNode *CF = dyn_cast<ConstantFPSDNode>(Ld))
5672       Ld = DAG.getLoad(
5677       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5681   bool IsLoad = ISD::isNormalLoad(Ld.getNode());
5686     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5694     return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
5698   if (Subtarget->hasInt256() && Ld.getValueType().isInteger()) {
5700       return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
8242     LoadSDNode *Ld = cast<LoadSDNode>(BC);
8243     SDValue BaseAddr = Ld->getOperand(1);
8250     V = DAG.getLoad(SVT, DL, Ld->getChain(), NewAddr,
8252                         Ld->getMemOperand(), Offset, SVT.getStoreSize()));
12110           if (SDValue Ld = EltsFromConsecutiveLoads(OpVT, Ops, dl, DAG, false))
12111             return Ld;
15478   LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
15479   SDLoc dl(Ld);
15480   EVT MemVT = Ld->getMemoryVT();
15484   ISD::LoadExtType Ext = Ld->getExtensionType();
15510       Load = DAG.getLoad(MemVT, dl, Ld->getChain(), Ld->getBasePtr(),
15511                   Ld->getPointerInfo(), Ld->isVolatile(), Ld->isNonTemporal(),
15512                   Ld->isInvariant(), Ld->getAlignment());
15524           DAG.getExtLoad(Ext, dl, HalfVecVT, Ld->getChain(), Ld->getBasePtr(),
15525                          Ld->getPointerInfo(), MemVT, Ld->isVolatile(),
15526                          Ld->isNonTemporal(), Ld->isInvariant(),
15527                          Ld->getAlignment());
15532     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), Load.getValue(1));
15586   SDValue Ptr = Ld->getBasePtr();
15594         DAG.getLoad(SclrLoadTy, dl, Ld->getChain(), Ptr, Ld->getPointerInfo(),
15595                     Ld->isVolatile(), Ld->isNonTemporal(), Ld->isInvariant(),
15596                     Ld->getAlignment());
15620       DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
15630     DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
15644   DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), TF);
23033     if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(V1.getOperand(0))) {
23034       if (Ld->hasNUsesOfValue(1, 0)) {
23036         SDValue Ops[] = { Ld->getChain(), Ld->getBasePtr() };
23039                                   Ld->getMemoryVT(),
23040                                   Ld->getPointerInfo(),
23041                                   Ld->getAlignment(),
23045         // Make sure the newly-created LOAD is in the same position as Ld in
23046         // terms of dependency. We create a TokenFactor for Ld and ResNode,
23047         // and update uses of Ld's output chain to use the TokenFactor.
23048         if (Ld->hasAnyUseOfValue(1)) {
23050                              SDValue(Ld, 1), SDValue(ResNode.getNode(), 1));
23051           DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), NewChain);
23052           DAG.UpdateNodeOperands(NewChain.getNode(), SDValue(Ld, 1),
26267   LoadSDNode *Ld = cast<LoadSDNode>(N);
26268   EVT RegVT = Ld->getValueType(0);
26269   EVT MemVT = Ld->getMemoryVT();
26270   SDLoc dl(Ld);
26275   ISD::LoadExtType Ext = Ld->getExtensionType();
26277   unsigned AddressSpace = Ld->getAddressSpace();
26278   unsigned Alignment = Ld->getAlignment();
26287     SDValue Ptr = Ld->getBasePtr();
26293     SDValue Load1 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
26294                                 Ld->getPointerInfo(), Ld->isVolatile(),
26295                                 Ld->isNonTemporal(), Ld->isInvariant(),
26298     SDValue Load2 = DAG.getLoad(HalfVT, dl, Ld->getChain(), Ptr,
26299                                 Ld->getPointerInfo(), Ld->isVolatile(),
26300                                 Ld->isNonTemporal(), Ld->isInvariant(),
26638     LoadSDNode *Ld = nullptr;
26646       Ld = cast<LoadSDNode>(St->getChain());
26652           Ld = cast<LoadSDNode>(St->getValue());
26658     if (!Ld || !ISD::isNormalLoad(Ld))
26664     if (!VT.isVector() && !Ld->hasNUsesOfValue(1, 0))
26667     SDLoc LdDL(Ld);
26674       SDValue NewLd = DAG.getLoad(LdVT, LdDL, Ld->getChain(), Ld->getBasePtr(),
26675                                   Ld->getPointerInfo(), Ld->isVolatile(),
26676                                   Ld->isNonTemporal(), Ld->isInvariant(),
26677                                   Ld->getAlignment());
26690     SDValue LoAddr = Ld->getBasePtr();
26694     SDValue LoLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), LoAddr,
26695                                Ld->getPointerInfo(),
26696                                Ld->isVolatile(), Ld->isNonTemporal(),
26697                                Ld->isInvariant(), Ld->getAlignment());
26698     SDValue HiLd = DAG.getLoad(MVT::i32, LdDL, Ld->getChain(), HiAddr,
26699                                Ld->getPointerInfo().getWithOffset(4),
26700                                Ld->isVolatile(), Ld->isNonTemporal(),
26701                                Ld->isInvariant(),
26702                                MinAlign(Ld->getAlignment(), 4));
27828     LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
27829     EVT LdVT = Ld->getValueType(0);
27835     if (!Ld->isVolatile() && !VT.isVector() &&
27839           SDValue(N, 0), LdVT, Ld->getChain(), Op0, DAG);