[DAGCombiner][SelectionDAG] Apply CombineStoreAndExtract on constant values

[tingwang]

Summary

Given there is a constant vector and constant scalar both are stored under the same root node, if the scalar happens to bit wise match some specific vector element, then backend may reuse vector element for the scalar store.

It seems inevitable that I need to search through store values. That kind of search is already conducted in getStoreMergeCandidates(), so I think it maybe a good place to push some addition search logic.

I added shouldReuseConstVectorForExtractStore() to bail out early if backend does not need this kind of combine.

One hack I feel like have to do is to get EXTRACT_VECTOR_ELT node from DAG under some condition. Without that I'm afraid cannot form the pattern for instruction selection. Let me know if there is any other way to achieve this in DAG. Thank you!

[tingwang]

Some test case to sanity check constants are stored as expected:

test.c4 KBDownload

main.c4 KBDownload

I built them separately and linked with -O3, and verified results identical on LE/BE before and after this patch.

[tingwang]

Saw error in bootstrap.

[tingwang]

Updates:
(1) Do not combine when store node generates additional value(s).
(2) Add getCombineStoreAndExtractIdx() to directly query the index, and do not need to loop through all elements.
(3) If the constant value to be stored is referenced by node other than current Store and the vector node, do not combine.
(4) Do not combine if the constant value is -1U.
(5) Add check to make sure the to-be-extracted vector type is legal.

Bootstrap is clean with this version.

[tingwang]

Not useful, since dependent is abandoned.

llvm/include/llvm/CodeGen/TargetLowering.h

public:
   /// Return true if the target can combine store(extractelement VectorTy,
   /// Idx).
   /// \p Cost[out] gives the cost of that transformation when this is true.
   virtual bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
                                          unsigned &Cost) const {
     return false;
   }
 
+  /// Return true if the target can reuse part of constant vector for extract
+  /// and store.
+  virtual bool shouldReuseConstVectorForExtractStore() const { return false; }
+
   /// Return true if inserting a scalar into a variable element of an undef
   /// vector is more efficiently handled by splatting the scalar instead.
   virtual bool shouldSplatInsEltVarIndex(EVT) const {
     return false;
   }
 
   /// Return true if target always benefits from combining into FMA for a
   /// given value type. This must typically return false on targets where FMA
virtual EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
                                  EVT VT) const;
 
   /// Return the ValueType for comparison libcalls. Comparison libcalls include
   /// floating point comparison calls, and Ordered/Unordered check calls on
   /// floating point numbers.
   virtual
   MVT::SimpleValueType getCmpLibcallReturnType() const;
 
+  /// Return the index of vector element for efficient store(extractelement).
+  virtual unsigned getCombineStoreAndExtractIdx(unsigned BitWidth) const {
+    return -1U;
+  }
+
   /// For targets without i1 registers, this gives the nature of the high-bits
   /// of boolean values held in types wider than i1.
   ///
   /// "Boolean values" are special true/false values produced by nodes like
   /// SETCC and consumed (as the condition) by nodes like SELECT and BRCOND.
   /// Not to be confused with general values promoted from i1.  Some cpus
   /// distinguish between vectors of boolean and scalars; the isVec parameter
   /// selects between the two kinds.  For example on X86 a scalar boolean should

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

private:
     /// bitcasts if necessary.  \return True if a merged store was created.
     bool mergeStoresOfConstantsOrVecElts(SmallVectorImpl<MemOpLink> &StoreNodes,
                                          EVT MemVT, unsigned NumStores,
                                          bool IsConstantSrc, bool UseVector,
                                          bool UseTrunc);
 
     /// This is a helper function for mergeConsecutiveStores. Stores that
     /// potentially may be merged with St are placed in StoreNodes. RootNode is
-    /// a chain predecessor to all store candidates.
+    /// a chain predecessor to all store candidates. Optionally constant vector
+    /// which has element bit wise match the store source is placed in VectorVal
+    /// and VectorVT, the element index is placed in ExtractIdx.
     void getStoreMergeCandidates(StoreSDNode *St,
                                  SmallVectorImpl<MemOpLink> &StoreNodes,
-                                 SDNode *&Root);
+                                 SDNode *&Root, SDValue &VectorVal,
+                                 EVT &VectorVT, unsigned &ExtractIdx);
 
     /// Helper function for mergeConsecutiveStores. Checks if candidate stores
     /// have indirect dependency through their operands. RootNode is the
     /// predecessor to all stores calculated by getStoreMergeCandidates and is
     /// used to prune the dependency check. \return True if safe to merge.
     bool checkMergeStoreCandidatesForDependencies(
         SmallVectorImpl<MemOpLink> &StoreNodes, unsigned NumStores,
         SDNode *RootNode);
private:
 
     /// This is a helper function for mergeConsecutiveStores. It is used for
     /// store chains that are composed entirely of loaded values.
     bool tryStoreMergeOfLoads(SmallVectorImpl<MemOpLink> &StoreNodes,
                               unsigned NumConsecutiveStores, EVT MemVT,
                               SDNode *Root, bool AllowVectors,
                               bool IsNonTemporalStore, bool IsNonTemporalLoad);
 
-    /// Merge consecutive store operations into a wide store.
-    /// This optimization uses wide integers or vectors when possible.
-    /// \return true if stores were merged.
+    /// Merge consecutive store operations into a wide store. If no such merge
+    /// is possible, and the constant integer or float-point source bit wise
+    /// matches part of constant vector source which will be stored under the
+    /// same root node, extract-and-store pattern will be generated if backend
+    /// can support the combine. This optimization uses wide integers or vectors
+    /// when possible. \return true if stores were merged or extract-and-store
+    /// pattern generated.
     bool mergeConsecutiveStores(StoreSDNode *St);
 
     /// Try to transform a truncation where C is a constant:
     ///     (trunc (and X, C)) -> (and (trunc X), (trunc C))
     ///
     /// \p N needs to be a truncation and its first operand an AND. Other
     /// requirements are checked by the function (e.g. that trunc is
     /// single-use) and if missed an empty SDValue is returned.
bool DAGCombiner::mergeStoresOfConstantsOrVecElts(
   for (unsigned i = 0; i < NumStores; ++i)
     CombineTo(StoreNodes[i].MemNode, NewStore);
 
   AddToWorklist(NewChain.getNode());
   return true;
 }
 
 void DAGCombiner::getStoreMergeCandidates(
-    StoreSDNode *St, SmallVectorImpl<MemOpLink> &StoreNodes,
-    SDNode *&RootNode) {
+    StoreSDNode *St, SmallVectorImpl<MemOpLink> &StoreNodes, SDNode *&RootNode,
+    SDValue &VectorVal, EVT &VectorVT, unsigned &ExtractIdx) {
   // This holds the base pointer, index, and the offset in bytes from the base
   // pointer. We must have a base and an offset. Do not handle stores to undef
   // base pointers.
   BaseIndexOffset BasePtr = BaseIndexOffset::match(St, DAG);
   if (!BasePtr.getBase().getNode() || BasePtr.getBase().isUndef())
     return;
 
   SDValue Val = peekThroughBitcasts(St->getValue());
if (StoreSrc == StoreSource::Load) {
     // Loads must only have one use.
     if (!Ld->hasNUsesOfValue(1, 0))
       return;
     // The memory operands must not be volatile/indexed/atomic.
     // TODO: May be able to relax for unordered atomics (see D66309)
     if (!Ld->isSimple() || Ld->isIndexed())
       return;
   }
+  // Check if OtherBC is constant vector which has one element bit wise matches
+  // constant store source of St, and backend supports the extract-and-store
+  // pattern.
+  auto ConstVectorCandidateMatch = [&](SDValue &OtherBC) -> void {
+    // May improve only if the stored value has no use other than St and
+    // OtherBC.
+    for (auto I = Val.getNode()->use_begin(), E = Val.getNode()->use_end();
+         I != E; ++I) {
+      if (*I != St && *I != OtherBC.getNode())
+        return;
+    }
+    if (VectorVal != SDValue())
+      return;
+    if (OtherBC.getOpcode() != ISD::BUILD_VECTOR)
+      return;
+    if (!isTypeLegal(OtherBC.getValueType()))
+      return;
+    // Truncated stores are likely simple constants. Stores that return values
+    // are out-of-scope. Do not bother reuse.
+    if (St->isTruncatingStore() || St->getNumValues() != 1)
+      return;
+    unsigned StoreSizeInBits = MemVT.getSizeInBits();
+    // Only for full word power of two types.
+    if (StoreSizeInBits < 32 || !llvm::isPowerOf2_64(StoreSizeInBits))
+      return;
+    // Get the constant source value for St.
+    APInt ConstVal;
+    if (auto *Const = dyn_cast<ConstantSDNode>(Val)) {
+      ConstVal = Const->getAPIntValue();
+    } else if (auto *Const = dyn_cast<ConstantFPSDNode>(Val)) {
+      ConstVal = Const->getValueAPF().bitcastToAPInt();
+    } else
+      return;
+    // Do not combine if active bits fit in halfword or -1U
+    if (ConstVal.isIntN(16) || ConstVal.isAllOnes())
+      return;
+
+    // Create vector type for extract.
+    unsigned NElts = OtherBC.getValueType().getSizeInBits() / StoreSizeInBits;
+    if (NElts * StoreSizeInBits != OtherBC.getValueType().getSizeInBits())
+      return;
+    EVT SVT = EVT::getVectorVT(*DAG.getContext(), Val.getValueType(), NElts);
+    if (!isTypeLegal(SVT))
+      return;
+
+    ExtractIdx = TLI.getCombineStoreAndExtractIdx(StoreSizeInBits);
+    if (ExtractIdx == -1U)
+      return;
+
+    // Collect to-be-extracted bits from vector elements and check.
+    SmallVector<APInt> Fragments;
+    unsigned VecElemSizeInBits =
+        OtherBC.getValueType().getScalarType().getSizeInBits();
+    unsigned ExtractLowIdx = ExtractIdx * StoreSizeInBits;
+    unsigned ExtractHighIdx = ExtractLowIdx + StoreSizeInBits;
+    unsigned BitLow = 0;
+    unsigned BitHigh = BitLow + VecElemSizeInBits;
+    for (const SDValue &Op : OtherBC->op_values()) {
+      // Bail out if any lane is not defined.
+      if (Op.isUndef())
+        return;
+      // Element should be constant integer or float-point.
+      APInt ElemVal;
+      if (auto *Const = dyn_cast<ConstantSDNode>(Op)) {
+        ElemVal = Const->getAPIntValue();
+      } else if (auto *Const = dyn_cast<ConstantFPSDNode>(Op)) {
+        ElemVal = Const->getValueAPF().bitcastToAPInt();
+      } else
+        return;
+      // Push part of element that intersects with [ExtractLowIdx,
+      // ExtractHighIdx) into Fragments.
+      if (BitHigh >= ExtractLowIdx && ExtractHighIdx >= BitLow &&
+          BitHigh != ExtractLowIdx && BitLow != ExtractHighIdx)
+        Fragments.push_back(ElemVal.extractBits(
+            ((BitHigh > ExtractHighIdx ? ExtractHighIdx : BitHigh) -
+             (BitLow > ExtractLowIdx ? BitLow : ExtractLowIdx)),
+            (BitLow >= ExtractLowIdx ? 0 : (ExtractLowIdx - BitLow))));
+      // Update element position for the next one.
+      BitLow = BitHigh;
+      BitHigh = BitLow + VecElemSizeInBits;
+    }
+
+    // Make sure we got fragments, and swap for BigEndian.
+    if (Fragments.size() == 0)
+      return;
+    if (DAG.getDataLayout().isBigEndian())
+      std::reverse(Fragments.begin(), Fragments.end());
+
+    // Merge all fragments and check identical.
+    APInt Concat = *Fragments.rbegin();
+    for (APInt I : make_range(Fragments.rbegin() + 1, Fragments.rend()))
+      Concat = Concat.concat(I);
+    assert(Concat.getBitWidth() == ConstVal.getBitWidth());
+    if (Concat != ConstVal)
+      return;
+
+    // See if backend supports the combine, and check for least cost.
+    unsigned TmpC;
+    if (TLI.canCombineStoreAndExtract(
+            SVT.getTypeForEVT(*DAG.getContext()),
+            ConstantInt::get(*DAG.getContext(), APInt(16, ExtractIdx)), TmpC)) {
+      VectorVal = OtherBC;
+      VectorVT = SVT;
+    }
+    return;
+  };
+
   auto CandidateMatch = [&](StoreSDNode *Other, BaseIndexOffset &Ptr,
                             int64_t &Offset) -> bool {
     // The memory operands must not be volatile/indexed/atomic.
     // TODO: May be able to relax for unordered atomics (see D66309)
     if (!Other->isSimple() || Other->isIndexed())
       return false;
     // Don't mix temporal stores with non-temporal stores.
     if (St->isNonTemporal() != Other->isNonTemporal())
case StoreSource::Load: {
       // Don't mix temporal loads with non-temporal loads.
       if (cast<LoadSDNode>(Val)->isNonTemporal() != OtherLd->isNonTemporal())
         return false;
       if (!(LBasePtr.equalBaseIndex(LPtr, DAG)))
         return false;
       break;
     }
     case StoreSource::Constant:
+      // Optionally check if there is opportunity to reuse constant.
+      if (TLI.shouldReuseConstVectorForExtractStore() && Other != St) {
+        ConstVectorCandidateMatch(OtherBC);
+      }
       if (NoTypeMatch)
         return false;
       if (!isIntOrFPConstant(OtherBC))
         return false;
       break;
     case StoreSource::Extract:
       // Do not merge truncated stores here.
       if (Other->isTruncatingStore())
bool DAGCombiner::mergeConsecutiveStores(StoreSDNode *St) {
   // extracted vector elements.
   SDValue StoredVal = peekThroughBitcasts(St->getValue());
   const StoreSource StoreSrc = getStoreSource(StoredVal);
   if (StoreSrc == StoreSource::Unknown)
     return false;
 
   SmallVector<MemOpLink, 8> StoreNodes;
   SDNode *RootNode;
+  SDValue VectorVal;
+  EVT VectorVT;
+  unsigned ExtractIdx = -1;
   // Find potential store merge candidates by searching through chain sub-DAG
-  getStoreMergeCandidates(St, StoreNodes, RootNode);
+  getStoreMergeCandidates(St, StoreNodes, RootNode, VectorVal, VectorVT,
+                          ExtractIdx);
 
   // Check if there is anything to merge.
-  if (StoreNodes.size() < 2)
+  if (StoreNodes.size() < 2) {
+    // Explore constant reuse only when nothing to merge.
+    if (!TLI.shouldReuseConstVectorForExtractStore() || VectorVal == SDValue())
+      return false;
+    // Constant Vector for extract-and-store has been identified. Generate
+    // pattern for isel.
+    SDLoc DL(St);
+    SDValue ValToExtract = DAG.getNode(ISD::BITCAST, DL, VectorVT, VectorVal);
+    if (ValToExtract.isUndef())
+      return false;
+    SDValue Value =
+        DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, StoredVal.getValueType(),
+                    ValToExtract, DAG.getVectorIdxConstant(ExtractIdx, DL));
+    if (Value.getOpcode() != ISD::EXTRACT_VECTOR_ELT)
+      return false;
+    SDValue ValToStore =
+        DAG.getNode(ISD::BITCAST, DL, St->getValue().getValueType(), Value);
+    if (ValToStore.isUndef())
       return false;
+    SDValue NewStore = DAG.getStore(St->getChain(), DL, ValToStore,
+                                    St->getBasePtr(), St->getMemOperand());
+    if (NewStore.getOpcode() != ISD::STORE)
+      return false;
+    CombineTo(St, NewStore);
+    AddToWorklist(NewStore.getNode());
+    return true;
+  }
 
   // Sort the memory operands according to their distance from the
   // base pointer.
   llvm::sort(StoreNodes, [](MemOpLink LHS, MemOpLink RHS) {
     return LHS.OffsetFromBase < RHS.OffsetFromBase;
   });
 
   bool AllowVectors = !DAG.getMachineFunction().getFunction().hasFnAttribute(

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
   auto *N1C = dyn_cast<ConstantSDNode>(N1);
   auto *N2C = dyn_cast<ConstantSDNode>(N2);
 
   // Don't allow undefs in vector splats - we might be returning N2 when folding
   // to zero etc.
   ConstantSDNode *N2CV =
       isConstOrConstSplat(N2, /*AllowUndefs*/ false, /*AllowTruncation*/ true);
 
+  // Explore the opportunity that part of constant vector to be stored can be
+  // reused as source for another store during combine.
+  auto CanReuseConstVectorElemForStore = [&](SDValue N1, ConstantSDNode *N2C) {
+    if (!TLI->shouldReuseConstVectorForExtractStore())
+      return false;
+    if (N1.getOpcode() != ISD::BUILD_VECTOR)
+      return false;
+    // The source vector need be constant.
+    if (!(ISD::isBuildVectorOfConstantSDNodes(N1.getNode()) ||
+          ISD::isBuildVectorOfConstantFPSDNodes(N1.getNode())))
+      return false;
+    // Check if there is pattern for extract and store.
+    unsigned TmpC;
+    if (!TLI->canCombineStoreAndExtract(
+            N1.getValueType().getTypeForEVT(*getContext()),
+            ConstantInt::get(*getContext(), APInt(16, N2C->getZExtValue())),
+            TmpC))
+      return false;
+    // Constant vector need have a store use to make sure it will not be
+    // combined away.
+    for (auto UI = N1->use_begin(), UE = N1->use_end(); UI != UE; ++UI) {
+      if (UI->getOpcode() == ISD::STORE)
+        return true;
+    }
+    return false;
+  };
+
   switch (Opcode) {
   default: break;
   case ISD::TokenFactor:
     assert(VT == MVT::Other && N1.getValueType() == MVT::Other &&
            N2.getValueType() == MVT::Other && "Invalid token factor!");
     // Fold trivial token factors.
     if (N1.getOpcode() == ISD::EntryToken) return N2;
     if (N2.getOpcode() == ISD::EntryToken) return N1;
if (N2C && N1.getOperand(0).getValueType().isFixedLengthVector() &&
         N1.getOperand(0).getValueType().getVectorNumElements();
       return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
                      N1.getOperand(N2C->getZExtValue() / Factor),
                      getVectorIdxConstant(N2C->getZExtValue() % Factor, DL));
     }
 
     // EXTRACT_VECTOR_ELT of BUILD_VECTOR or SPLAT_VECTOR is often formed while
     // lowering is expanding large vector constants.
-    if (N2C && (N1.getOpcode() == ISD::BUILD_VECTOR ||
-                N1.getOpcode() == ISD::SPLAT_VECTOR)) {
+    if (N2C &&
+        (N1.getOpcode() == ISD::BUILD_VECTOR ||
+         N1.getOpcode() == ISD::SPLAT_VECTOR) &&
+        !CanReuseConstVectorElemForStore(N1, N2C)) {
       assert((N1.getOpcode() != ISD::BUILD_VECTOR ||
               N1.getValueType().isFixedLengthVector()) &&
              "BUILD_VECTOR used for scalable vectors");
       unsigned Index =
           N1.getOpcode() == ISD::BUILD_VECTOR ? N2C->getZExtValue() : 0;
       SDValue Elt = N1.getOperand(Index);
 
       if (VT != Elt.getValueType())

llvm/lib/Target/PowerPC/PPCISelLowering.h

public:
 
     bool isCheapToSpeculateCtlz(Type *Ty) const override {
       return true;
     }
 
     bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
                                    unsigned &Cost) const override;
 
+    unsigned getCombineStoreAndExtractIdx(unsigned BitWidth) const override;
+
+    bool shouldReuseConstVectorForExtractStore() const override { return true; }
+
     bool isCtlzFast() const override {
       return true;
     }
 
     bool isEqualityCmpFoldedWithSignedCmp() const override {
       return false;
     }
 

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

bool PPCTargetLowering::canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
   // operation.
   if (cast<ConstantInt>(Idx)->getZExtValue() == ElemIdx) {
     Cost = 1;
     return true;
   }
   return false;
 }
 
+unsigned PPCTargetLowering::getCombineStoreAndExtractIdx(unsigned BitWidth) const {
+  unsigned Idx = -1U;
+  if (!Subtarget.isPPC64() || !Subtarget.hasVSX())
+    return Idx;
+  if (BitWidth == 32 && Subtarget.hasP8Vector()) {
+    Idx = Subtarget.isLittleEndian() ? 2 : 1;
+  } else if (BitWidth == 64) {
+    Idx = Subtarget.isLittleEndian() ? 1 : 0;
+  }
+  return Idx;
+}
+
 const char *PPCTargetLowering::getTargetNodeName(unsigned Opcode) const {
   switch ((PPCISD::NodeType)Opcode) {
   case PPCISD::FIRST_NUMBER:    break;
   case PPCISD::FSEL:            return "PPCISD::FSEL";
   case PPCISD::XSMAXC:          return "PPCISD::XSMAXC";
   case PPCISD::XSMINC:          return "PPCISD::XSMINC";
   case PPCISD::FCFID:           return "PPCISD::FCFID";
   case PPCISD::FCFIDU:          return "PPCISD::FCFIDU";

llvm/test/CodeGen/PowerPC/const-nonsplat-array-init.ll

 ; RUN:   -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s --check-prefix=P9-LE
 ; RUN: llc -verify-machineinstrs -mcpu=pwr10 \
 ; RUN:   -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s --check-prefix=P10-LE
 
 define dso_local void @foo1_int_be_reuse4B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo1_int_be_reuse4B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C0(2) # %const.0
+; P8-BE-NEXT:    li 5, 2057
+; P8-BE-NEXT:    sth 5, 20(3)
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
-; P8-BE-NEXT:    stw 4, 16(3)
-; P8-BE-NEXT:    li 4, 2057
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    sth 4, 20(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo1_int_be_reuse4B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C0(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    li 4, 2057
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    sth 4, 20(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo1_int_be_reuse4B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C0(2) # %const.0
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 67438087
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    li 4, 2057
-; P10-BE-NEXT:    sth 4, 20(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    sth 4, 20(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo1_int_be_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI0_0@toc@ha
 ; P8-LE-NEXT:    li 5, 2312
 ; P8-LE-NEXT:    addi 4, 4, .LCPI0_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4

 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo2_int_le_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI1_0@toc@ha
 ; P8-LE-NEXT:    li 5, 3340
 ; P8-LE-NEXT:    addi 4, 4, .LCPI1_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 2826
-; P8-LE-NEXT:    ori 4, 4, 2312
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
 ; P8-LE-NEXT:    sth 5, 20(3)
+; P8-LE-NEXT:    stfiwx 1, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo2_int_le_reuse4B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI1_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI1_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 2826
-; P9-LE-NEXT:    ori 4, 4, 2312
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    li 4, 3340
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    sth 4, 20(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo2_int_le_reuse4B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI1_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 185207048
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    li 4, 3340
-; P10-LE-NEXT:    sth 4, 20(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    sth 4, 20(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, ptr %a, align 1
   %arrayidx16 = getelementptr inbounds i8, ptr %a, i64 16
   store i8 8, ptr %arrayidx16, align 1
   %arrayidx17 = getelementptr inbounds i8, ptr %a, i64 17
   store i8 9, ptr %arrayidx17, align 1
   %arrayidx18 = getelementptr inbounds i8, ptr %a, i64 18
   store i8 10, ptr %arrayidx18, align 1
   %arrayidx19 = getelementptr inbounds i8, ptr %a, i64 19
   store i8 11, ptr %arrayidx19, align 1
   %arrayidx20 = getelementptr inbounds i8, ptr %a, i64 20
   store i8 12, ptr %arrayidx20, align 1
   %arrayidx21 = getelementptr inbounds i8, ptr %a, i64 21
   store i8 13, ptr %arrayidx21, align 1
   ret void
 }
 
 define dso_local void @foo3_int_be_reuse4B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo3_int_be_reuse4B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C2(2) # %const.0
+; P8-BE-NEXT:    li 5, 2057
+; P8-BE-NEXT:    sth 5, 20(3)
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
-; P8-BE-NEXT:    stw 4, 16(3)
-; P8-BE-NEXT:    li 4, 2057
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    sth 4, 20(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo3_int_be_reuse4B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C2(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    li 4, 2057
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    sth 4, 20(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo3_int_be_reuse4B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C2(2) # %const.0
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 67438087
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    li 4, 2057
-; P10-BE-NEXT:    sth 4, 20(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    sth 4, 20(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo3_int_be_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI2_0@toc@ha
 ; P8-LE-NEXT:    li 5, 2057
 ; P8-LE-NEXT:    addi 4, 4, .LCPI2_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4

 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo4_int_le_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI3_0@toc@ha
 ; P8-LE-NEXT:    li 5, 3085
 ; P8-LE-NEXT:    addi 4, 4, .LCPI3_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 2571
-; P8-LE-NEXT:    ori 4, 4, 2057
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
 ; P8-LE-NEXT:    sth 5, 20(3)
+; P8-LE-NEXT:    stfiwx 1, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo4_int_le_reuse4B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI3_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI3_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 2571
-; P9-LE-NEXT:    ori 4, 4, 2057
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    li 4, 3085
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    sth 4, 20(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo4_int_le_reuse4B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI3_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 168495113
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    li 4, 3085
-; P10-LE-NEXT:    sth 4, 20(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    sth 4, 20(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <8 x i16> <i16 1, i16 515, i16 1029, i16 1543, i16 2057, i16 2571, i16 3085, i16 3599>, ptr %a, align 2
   %arrayidx8 = getelementptr inbounds i16, ptr %a, i64 8
   store i16 2057, ptr %arrayidx8, align 2
   %arrayidx9 = getelementptr inbounds i16, ptr %a, i64 9
   store i16 2571, ptr %arrayidx9, align 2
   %arrayidx10 = getelementptr inbounds i16, ptr %a, i64 10
   store i16 3085, ptr %arrayidx10, align 2
   ret void
 }
 
 define dso_local void @foo5_int_be_reuse4B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo5_int_be_reuse4B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C4(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo5_int_be_reuse4B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C4(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo5_int_be_reuse4B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C4(2) # %const.0
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 67438087
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo5_int_be_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI4_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI4_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
 ; P8-LE-NEXT:    lis 4, 1029

 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo6_int_le_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI5_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI5_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 2057
-; P8-LE-NEXT:    ori 4, 4, 2571
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 1, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo6_int_le_reuse4B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI5_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI5_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 2057
-; P9-LE-NEXT:    ori 4, 4, 2571
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo6_int_le_reuse4B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI5_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 134810123
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x i32> <i32 66051, i32 67438087, i32 134810123, i32 202182159>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds i32, ptr %a, i64 4
   store i32 134810123, ptr %arrayidx4, align 4
   ret void
 }
 
 define dso_local void @foo7_int_be_reuse8B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo7_int_be_reuse8B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C6(2) # %const.0
-; P8-BE-NEXT:    lis 5, 1
-; P8-BE-NEXT:    ori 5, 5, 515
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    rldic 4, 5, 32, 15
-; P8-BE-NEXT:    oris 4, 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo7_int_be_reuse8B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C6(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1
-; P9-BE-NEXT:    ori 4, 4, 515
-; P9-BE-NEXT:    rldic 4, 4, 32, 15
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    oris 4, 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo7_int_be_reuse8B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C6(2) # %const.0
-; P10-BE-NEXT:    pli 5, 67438087
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 66051
-; P10-BE-NEXT:    rldimi 5, 4, 32, 0
-; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo7_int_be_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI6_0@toc@ha
 ; P8-LE-NEXT:    lis 5, 449
 ; P8-LE-NEXT:    addi 4, 4, .LCPI6_0@toc@l
 ; P8-LE-NEXT:    ori 5, 5, 33089

 ; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo8_int_le_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI7_0@toc@ha
-; P8-LE-NEXT:    lis 5, 963
 ; P8-LE-NEXT:    addi 4, 4, .LCPI7_0@toc@l
-; P8-LE-NEXT:    ori 5, 5, 33603
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    rldic 4, 5, 34, 4
-; P8-LE-NEXT:    oris 4, 4, 2826
-; P8-LE-NEXT:    ori 4, 4, 2312
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 1, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo8_int_le_reuse8B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI7_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI7_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 963
-; P9-LE-NEXT:    ori 4, 4, 33603
-; P9-LE-NEXT:    rldic 4, 4, 34, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    oris 4, 4, 2826
-; P9-LE-NEXT:    ori 4, 4, 2312
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo8_int_le_reuse8B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI7_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 252579084
-; P10-LE-NEXT:    pli 5, 185207048
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, ptr %a, align 1
   %arrayidx16 = getelementptr inbounds i8, ptr %a, i64 16
   store i8 8, ptr %arrayidx16, align 1
   %arrayidx17 = getelementptr inbounds i8, ptr %a, i64 17
   store i8 9, ptr %arrayidx17, align 1
   %arrayidx18 = getelementptr inbounds i8, ptr %a, i64 18
entry:
   store i8 15, ptr %arrayidx23, align 1
   ret void
 }
 
 define dso_local void @foo9_int_be_reuse8B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo9_int_be_reuse8B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C8(2) # %const.0
-; P8-BE-NEXT:    lis 5, 1
-; P8-BE-NEXT:    ori 5, 5, 515
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    rldic 4, 5, 32, 15
-; P8-BE-NEXT:    oris 4, 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo9_int_be_reuse8B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C8(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1
-; P9-BE-NEXT:    ori 4, 4, 515
-; P9-BE-NEXT:    rldic 4, 4, 32, 15
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    oris 4, 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo9_int_be_reuse8B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C8(2) # %const.0
-; P10-BE-NEXT:    pli 5, 67438087
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 66051
-; P10-BE-NEXT:    rldimi 5, 4, 32, 0
-; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo9_int_be_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI8_0@toc@ha
 ; P8-LE-NEXT:    lis 5, 1543
 ; P8-LE-NEXT:    addi 4, 4, .LCPI8_0@toc@l
 ; P8-LE-NEXT:    ori 5, 5, 1029

 ; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo10_int_le_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI9_0@toc@ha
-; P8-LE-NEXT:    lis 5, 3599
 ; P8-LE-NEXT:    addi 4, 4, .LCPI9_0@toc@l
-; P8-LE-NEXT:    ori 5, 5, 3085
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    rldic 4, 5, 32, 4
-; P8-LE-NEXT:    oris 4, 4, 2571
-; P8-LE-NEXT:    ori 4, 4, 2057
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 1, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo10_int_le_reuse8B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI9_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI9_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 3599
-; P9-LE-NEXT:    ori 4, 4, 3085
-; P9-LE-NEXT:    rldic 4, 4, 32, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    oris 4, 4, 2571
-; P9-LE-NEXT:    ori 4, 4, 2057
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo10_int_le_reuse8B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI9_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 235867149
-; P10-LE-NEXT:    pli 5, 168495113
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <8 x i16> <i16 1, i16 515, i16 1029, i16 1543, i16 2057, i16 2571, i16 3085, i16 3599>, ptr %a, align 2
   %arrayidx8 = getelementptr inbounds i16, ptr %a, i64 8
   store i16 2057, ptr %arrayidx8, align 2
   %arrayidx9 = getelementptr inbounds i16, ptr %a, i64 9
   store i16 2571, ptr %arrayidx9, align 2
   %arrayidx10 = getelementptr inbounds i16, ptr %a, i64 10
   store i16 3085, ptr %arrayidx10, align 2
   %arrayidx11 = getelementptr inbounds i16, ptr %a, i64 11
   store i16 3599, ptr %arrayidx11, align 2
   ret void
 }
 
 define dso_local void @foo11_int_be_reuse8B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo11_int_be_reuse8B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C10(2) # %const.0
-; P8-BE-NEXT:    lis 5, 1
-; P8-BE-NEXT:    ori 5, 5, 515
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    rldic 4, 5, 32, 15
-; P8-BE-NEXT:    oris 4, 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo11_int_be_reuse8B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C10(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1
-; P9-BE-NEXT:    ori 4, 4, 515
-; P9-BE-NEXT:    rldic 4, 4, 32, 15
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    oris 4, 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo11_int_be_reuse8B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C10(2) # %const.0
-; P10-BE-NEXT:    pli 5, 67438087
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 66051
-; P10-BE-NEXT:    rldimi 5, 4, 32, 0
-; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo11_int_be_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI10_0@toc@ha
 ; P8-LE-NEXT:    lis 5, 1029
 ; P8-LE-NEXT:    addi 4, 4, .LCPI10_0@toc@l
 ; P8-LE-NEXT:    ori 5, 5, 1543

 ; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo12_int_le_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI11_0@toc@ha
-; P8-LE-NEXT:    lis 5, 3085
 ; P8-LE-NEXT:    addi 4, 4, .LCPI11_0@toc@l
-; P8-LE-NEXT:    ori 5, 5, 3599
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    rldic 4, 5, 32, 4
-; P8-LE-NEXT:    oris 4, 4, 2057
-; P8-LE-NEXT:    ori 4, 4, 2571
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 1, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo12_int_le_reuse8B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI11_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI11_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 3085
-; P9-LE-NEXT:    ori 4, 4, 3599
-; P9-LE-NEXT:    rldic 4, 4, 32, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    oris 4, 4, 2057
-; P9-LE-NEXT:    ori 4, 4, 2571
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo12_int_le_reuse8B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI11_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 202182159
-; P10-LE-NEXT:    pli 5, 134810123
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x i32> <i32 66051, i32 67438087, i32 134810123, i32 202182159>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds i32, ptr %a, i64 4
   store i32 134810123, ptr %arrayidx4, align 4
   %arrayidx5 = getelementptr inbounds i32, ptr %a, i64 5
   store i32 202182159, ptr %arrayidx5, align 4
   ret void
 }
 
 define dso_local void @foo13_int_be_reuse8B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo13_int_be_reuse8B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C12(2) # %const.0
-; P8-BE-NEXT:    lis 5, 1
-; P8-BE-NEXT:    ori 5, 5, 515
 ; P8-BE-NEXT:    lxvd2x 0, 0, 4
-; P8-BE-NEXT:    rldic 4, 5, 32, 15
-; P8-BE-NEXT:    oris 4, 4, 1029
-; P8-BE-NEXT:    ori 4, 4, 1543
 ; P8-BE-NEXT:    stxvd2x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo13_int_be_reuse8B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C12(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 1
-; P9-BE-NEXT:    ori 4, 4, 515
-; P9-BE-NEXT:    rldic 4, 4, 32, 15
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    oris 4, 4, 1029
-; P9-BE-NEXT:    ori 4, 4, 1543
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo13_int_be_reuse8B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C12(2) # %const.0
-; P10-BE-NEXT:    pli 5, 67438087
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 66051
-; P10-BE-NEXT:    rldimi 5, 4, 32, 0
-; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo13_int_be_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI12_0@toc@ha
 ; P8-LE-NEXT:    lis 5, 1
 ; P8-LE-NEXT:    addi 4, 4, .LCPI12_0@toc@l
 ; P8-LE-NEXT:    ori 5, 5, 515

 ; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo14_int_le_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI13_0@toc@ha
-; P8-LE-NEXT:    lis 5, 2057
 ; P8-LE-NEXT:    addi 4, 4, .LCPI13_0@toc@l
-; P8-LE-NEXT:    ori 5, 5, 2571
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    rldic 4, 5, 32, 4
-; P8-LE-NEXT:    oris 4, 4, 3085
-; P8-LE-NEXT:    ori 4, 4, 3599
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 1, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo14_int_le_reuse8B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI13_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI13_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 2057
-; P9-LE-NEXT:    ori 4, 4, 2571
-; P9-LE-NEXT:    rldic 4, 4, 32, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    oris 4, 4, 3085
-; P9-LE-NEXT:    ori 4, 4, 3599
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo14_int_le_reuse8B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI13_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 134810123
-; P10-LE-NEXT:    pli 5, 202182159
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <2 x i64> <i64 283686952306183, i64 579005069656919567>, ptr %a, align 8
   %arrayidx2 = getelementptr inbounds i64, ptr %a, i64 2
   store i64 579005069656919567, ptr %arrayidx2, align 8
   ret void
 }
 
entry:
   ret void
 }
 
 define dso_local void @foo17_fp_be_reuse4B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo17_fp_be_reuse4B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C16(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 16673
-; P8-BE-NEXT:    ori 4, 4, 39322
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo17_fp_be_reuse4B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C16(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 16673
-; P9-BE-NEXT:    ori 4, 4, 39322
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo17_fp_be_reuse4B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C16(2) # %const.0
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    pli 4, 1092721050
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo17_fp_be_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI16_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI16_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
 ; P8-LE-NEXT:    lis 4, 16673

 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo18_fp_le_reuse4B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI17_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI17_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 16675
-; P8-LE-NEXT:    ori 4, 4, 13107
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 1, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo18_fp_le_reuse4B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI17_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI17_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 16675
-; P9-LE-NEXT:    ori 4, 4, 13107
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo18_fp_le_reuse4B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI17_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 1092825907
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x float> <float 1.000000e+00, float 0x3FF19999A0000000, float 0x4024666660000000, float 0x3FF4CCCCC0000000>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds float, ptr %a, i64 4
   store float 0x4024666660000000, ptr %arrayidx4, align 4
   ret void
 }
 
 define dso_local void @foo19_fp_be_reuse8B(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo19_fp_be_reuse8B:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C18(2) # %const.0
 ; P8-BE-NEXT:    lxvd2x 0, 0, 4
-; P8-BE-NEXT:    li 4, 4105
-; P8-BE-NEXT:    rldic 4, 4, 50, 1
-; P8-BE-NEXT:    std 4, 16(3)
 ; P8-BE-NEXT:    stxvd2x 0, 0, 3
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo19_fp_be_reuse8B:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C18(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    li 4, 4105
-; P9-BE-NEXT:    rldic 4, 4, 50, 1
-; P9-BE-NEXT:    std 4, 16(3)
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo19_fp_be_reuse8B:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    ld 4, L..C18(2) # %const.0
 ; P10-BE-NEXT:    lxv 0, 0(4)
-; P10-BE-NEXT:    li 4, 4105
-; P10-BE-NEXT:    rldic 4, 4, 50, 1
-; P10-BE-NEXT:    std 4, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo19_fp_be_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI18_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI18_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
 ; P8-LE-NEXT:    li 4, 4105

 ; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo20_fp_le_reuse8B:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI19_0@toc@ha
-; P8-LE-NEXT:    lis 5, 16420
 ; P8-LE-NEXT:    addi 4, 4, .LCPI19_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    ori 4, 5, 13107
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
-; P8-LE-NEXT:    rlwimi 4, 4, 16, 0, 15
+; P8-LE-NEXT:    xxswapd 1, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 1, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo20_fp_le_reuse8B:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI19_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI19_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 16420
-; P9-LE-NEXT:    ori 4, 4, 13107
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    rlwimi 4, 4, 16, 0, 15
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo20_fp_le_reuse8B:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    plxv 0, .LCPI19_0@PCREL(0), 1
-; P10-LE-NEXT:    pli 4, 1076114227
-; P10-LE-NEXT:    pli 5, 858993459
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <2 x double> <double 1.000000e+00, double 1.010000e+01>, ptr %a, align 8
   %arrayidx2 = getelementptr inbounds double, ptr %a, i64 2
   store double 1.010000e+01, ptr %arrayidx2, align 8
   ret void
 }
 

llvm/test/CodeGen/PowerPC/const-splat-array-init.ll

entry:
   ret void
 }
 
 define dso_local void @foo2(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo2:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C1(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 3333
-; P8-BE-NEXT:    ori 4, 4, 3333
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo2:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C1(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 3333
-; P9-BE-NEXT:    ori 4, 4, 3333
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo2:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    xxspltiw 0, 218434821
-; P10-BE-NEXT:    pli 4, 218434821
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo2:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI1_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI1_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 3333
-; P8-LE-NEXT:    ori 4, 4, 3333
+; P8-LE-NEXT:    li 4, 16
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo2:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI1_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI1_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 3333
-; P9-LE-NEXT:    ori 4, 4, 3333
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo2:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    xxspltiw 0, 218434821
-; P10-LE-NEXT:    pli 4, 218434821
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    blr
 entry:
   store <8 x i16> <i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333>, ptr %a, align 2
   %arrayidx8 = getelementptr inbounds i16, ptr %a, i64 8
   store i16 3333, ptr %arrayidx8, align 2
   %arrayidx9 = getelementptr inbounds i16, ptr %a, i64 9
   store i16 3333, ptr %arrayidx9, align 2
   ret void
 }
 
 define dso_local void @foo3(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo3:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C2(2) # %const.0
+; P8-BE-NEXT:    li 5, 3333
+; P8-BE-NEXT:    sth 5, 20(3)
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 3333
-; P8-BE-NEXT:    ori 4, 4, 3333
-; P8-BE-NEXT:    stw 4, 16(3)
-; P8-BE-NEXT:    li 4, 3333
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    sth 4, 20(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo3:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C2(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 3333
-; P9-BE-NEXT:    ori 4, 4, 3333
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    li 4, 3333
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    sth 4, 20(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo3:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 218434821
 ; P10-BE-NEXT:    xxspltiw 0, 218434821
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    li 4, 3333
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    sth 4, 20(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo3:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI2_0@toc@ha
 ; P8-LE-NEXT:    li 5, 3333
 ; P8-LE-NEXT:    addi 4, 4, .LCPI2_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 3333
-; P8-LE-NEXT:    ori 4, 4, 3333
+; P8-LE-NEXT:    li 4, 16
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    sth 5, 20(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo3:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI2_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI2_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 3333
-; P9-LE-NEXT:    ori 4, 4, 3333
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    li 4, 3333
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    sth 4, 20(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo3:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 218434821
 ; P10-LE-NEXT:    xxspltiw 0, 218434821
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    li 4, 3333
 ; P10-LE-NEXT:    stxv 0, 0(3)
 ; P10-LE-NEXT:    sth 4, 20(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <8 x i16> <i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333>, ptr %a, align 2
   %arrayidx8 = getelementptr inbounds i16, ptr %a, i64 8
   store i16 3333, ptr %arrayidx8, align 2
   %arrayidx9 = getelementptr inbounds i16, ptr %a, i64 9
   store i16 3333, ptr %arrayidx9, align 2
   %arrayidx10 = getelementptr inbounds i16, ptr %a, i64 10
   store i16 3333, ptr %arrayidx10, align 2
   ret void
 }
 
 define dso_local void @foo4(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo4:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C3(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 3333
-; P8-BE-NEXT:    ori 4, 4, 3333
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo4:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C3(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 3333
-; P9-BE-NEXT:    ori 4, 4, 3333
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo4:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 218434821
 ; P10-BE-NEXT:    xxspltiw 0, 218434821
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-BE-NEXT:    stxv 0, 0(3)
-; P10-BE-NEXT:    std 4, 16(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo4:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI3_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI3_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 3333
-; P8-LE-NEXT:    ori 4, 4, 3333
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo4:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI3_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI3_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 3333
-; P9-LE-NEXT:    ori 4, 4, 3333
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo4:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 218434821
 ; P10-LE-NEXT:    xxspltiw 0, 218434821
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-LE-NEXT:    stxv 0, 0(3)
-; P10-LE-NEXT:    std 4, 16(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <8 x i16> <i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333, i16 3333>, ptr %a, align 2
   %arrayidx8 = getelementptr inbounds i16, ptr %a, i64 8
   store i16 3333, ptr %arrayidx8, align 2
   %arrayidx9 = getelementptr inbounds i16, ptr %a, i64 9
   store i16 3333, ptr %arrayidx9, align 2
   %arrayidx10 = getelementptr inbounds i16, ptr %a, i64 10
   store i16 3333, ptr %arrayidx10, align 2
   %arrayidx11 = getelementptr inbounds i16, ptr %a, i64 11
   store i16 3333, ptr %arrayidx11, align 2
   ret void
 }
 
 define dso_local void @foo5(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo5:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C4(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 5
-; P8-BE-NEXT:    ori 4, 4, 5653
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo5:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C4(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 5
-; P9-BE-NEXT:    ori 4, 4, 5653
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo5:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    xxspltiw 0, 333333
-; P10-BE-NEXT:    pli 4, 333333
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo5:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI4_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI4_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 5
-; P8-LE-NEXT:    ori 4, 4, 5653
+; P8-LE-NEXT:    li 4, 16
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo5:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI4_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI4_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 5
-; P9-LE-NEXT:    ori 4, 4, 5653
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo5:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    xxspltiw 0, 333333
-; P10-LE-NEXT:    pli 4, 333333
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x i32> <i32 333333, i32 333333, i32 333333, i32 333333>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds i32, ptr %a, i64 4
   store i32 333333, ptr %arrayidx4, align 4
   ret void
 }
 
 define dso_local void @foo6(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo6:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C5(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 5
-; P8-BE-NEXT:    ori 4, 4, 5653
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo6:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C5(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 5
-; P9-BE-NEXT:    ori 4, 4, 5653
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo6:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 333333
 ; P10-BE-NEXT:    xxspltiw 0, 333333
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-BE-NEXT:    stxv 0, 0(3)
-; P10-BE-NEXT:    std 4, 16(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo6:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI5_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI5_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 5
-; P8-LE-NEXT:    ori 4, 4, 5653
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo6:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI5_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI5_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 5
-; P9-LE-NEXT:    ori 4, 4, 5653
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo6:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 333333
 ; P10-LE-NEXT:    xxspltiw 0, 333333
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-LE-NEXT:    stxv 0, 0(3)
-; P10-LE-NEXT:    std 4, 16(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x i32> <i32 333333, i32 333333, i32 333333, i32 333333>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds i32, ptr %a, i64 4
   store i32 333333, ptr %arrayidx4, align 4
   %arrayidx5 = getelementptr inbounds i32, ptr %a, i64 5
   store i32 333333, ptr %arrayidx5, align 4
   ret void
 }
 
 define dso_local void @foo7(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo7:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C6(2) # %const.0
 ; P8-BE-NEXT:    lxvd2x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 508
-; P8-BE-NEXT:    ori 4, 4, 41045
-; P8-BE-NEXT:    std 4, 16(3)
 ; P8-BE-NEXT:    stxvd2x 0, 0, 3
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo7:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C6(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 508
-; P9-BE-NEXT:    ori 4, 4, 41045
-; P9-BE-NEXT:    std 4, 16(3)
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo7:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    xxlxor 0, 0, 0
-; P10-BE-NEXT:    pli 4, 33333333
 ; P10-BE-NEXT:    xxsplti32dx 0, 1, 33333333
-; P10-BE-NEXT:    std 4, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo7:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI6_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI6_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 508
-; P8-LE-NEXT:    ori 4, 4, 41045
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo7:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI6_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI6_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 508
-; P9-LE-NEXT:    ori 4, 4, 41045
-; P9-LE-NEXT:    std 4, 16(3)
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo7:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    xxlxor 0, 0, 0
-; P10-LE-NEXT:    pli 4, 33333333
 ; P10-LE-NEXT:    xxsplti32dx 0, 1, 33333333
-; P10-LE-NEXT:    std 4, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <2 x i64> <i64 33333333, i64 33333333>, ptr %a, align 8
   %arrayidx2 = getelementptr inbounds i64, ptr %a, i64 2
   store i64 33333333, ptr %arrayidx2, align 8
   ret void
 }
 
 define dso_local void @foo8(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo8:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C7(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 16469
-; P8-BE-NEXT:    ori 4, 4, 7864
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo8:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C7(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 16469
-; P9-BE-NEXT:    ori 4, 4, 7864
-; P9-BE-NEXT:    stw 4, 16(3)
+; P9-BE-NEXT:    li 4, 16
 ; P9-BE-NEXT:    stxv 0, 0(3)
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo8:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    xxspltiw 0, 1079320248
-; P10-BE-NEXT:    pli 4, 1079320248
-; P10-BE-NEXT:    stw 4, 16(3)
+; P10-BE-NEXT:    li 4, 16
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo8:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI7_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI7_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 16469
-; P8-LE-NEXT:    ori 4, 4, 7864
+; P8-LE-NEXT:    li 4, 16
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo8:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI7_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI7_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 16469
-; P9-LE-NEXT:    ori 4, 4, 7864
-; P9-LE-NEXT:    stw 4, 16(3)
+; P9-LE-NEXT:    li 4, 16
 ; P9-LE-NEXT:    stxv 0, 0(3)
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo8:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    xxspltiw 0, 1079320248
-; P10-LE-NEXT:    pli 4, 1079320248
-; P10-LE-NEXT:    stw 4, 16(3)
+; P10-LE-NEXT:    li 4, 16
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x float> <float 0x400AA3D700000000, float 0x400AA3D700000000, float 0x400AA3D700000000, float 0x400AA3D700000000>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds float, ptr %a, i64 4
   store float 0x400AA3D700000000, ptr %arrayidx4, align 4
   ret void
 }
 
 define dso_local void @foo9(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo9:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C8(2) # %const.0
-; P8-BE-NEXT:    lis 5, 16394
-; P8-BE-NEXT:    ori 5, 5, 41943
 ; P8-BE-NEXT:    lxvd2x 0, 0, 4
-; P8-BE-NEXT:    rldic 4, 5, 32, 1
-; P8-BE-NEXT:    oris 4, 4, 2621
-; P8-BE-NEXT:    ori 4, 4, 28836
 ; P8-BE-NEXT:    stxvd2x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo9:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C8(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 16394
-; P9-BE-NEXT:    ori 4, 4, 41943
-; P9-BE-NEXT:    rldic 4, 4, 32, 1
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    oris 4, 4, 2621
-; P9-BE-NEXT:    ori 4, 4, 28836
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo9:
 ; P10-BE:       # %bb.0: # %entry
 ; P10-BE-NEXT:    xxsplti32dx 0, 0, 1074439127
-; P10-BE-NEXT:    pli 4, 1074439127
-; P10-BE-NEXT:    pli 5, 171798692
-; P10-BE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-BE-NEXT:    xxsplti32dx 0, 1, 171798692
-; P10-BE-NEXT:    std 5, 16(3)
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo9:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI8_0@toc@ha
-; P8-LE-NEXT:    lis 5, 16394
 ; P8-LE-NEXT:    addi 4, 4, .LCPI8_0@toc@l
-; P8-LE-NEXT:    ori 5, 5, 41943
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    rldic 4, 5, 32, 1
-; P8-LE-NEXT:    oris 4, 4, 2621
-; P8-LE-NEXT:    ori 4, 4, 28836
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo9:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI8_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI8_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 16394
-; P9-LE-NEXT:    ori 4, 4, 41943
-; P9-LE-NEXT:    rldic 4, 4, 32, 1
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    oris 4, 4, 2621
-; P9-LE-NEXT:    ori 4, 4, 28836
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo9:
 ; P10-LE:       # %bb.0: # %entry
 ; P10-LE-NEXT:    xxsplti32dx 0, 0, 1074439127
-; P10-LE-NEXT:    pli 4, 1074439127
-; P10-LE-NEXT:    pli 5, 171798692
-; P10-LE-NEXT:    rldimi 5, 4, 32, 0
 ; P10-LE-NEXT:    xxsplti32dx 0, 1, 171798692
-; P10-LE-NEXT:    std 5, 16(3)
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <2 x double> <double 3.330000e+00, double 3.330000e+00>, ptr %a, align 8
   %arrayidx2 = getelementptr inbounds double, ptr %a, i64 2
   store double 3.330000e+00, ptr %arrayidx2, align 8
   ret void
 }
 
 define dso_local void @foo10(ptr nocapture noundef writeonly %a) local_unnamed_addr {
 ; P8-BE-LABEL: foo10:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C9(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, 16469
-; P8-BE-NEXT:    ori 4, 4, 7864
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: foo10:
 ; P9-BE:       # %bb.0: # %entry
 ; P9-BE-NEXT:    ld 4, L..C9(2) # %const.0
 ; P9-BE-NEXT:    lxv 0, 0(4)
-; P9-BE-NEXT:    lis 4, 16469
-; P9-BE-NEXT:    ori 4, 4, 7864
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: foo10:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 1079320248
 ; P10-BE-NEXT:    xxspltiw 0, 1079320248
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-BE-NEXT:    stxv 0, 0(3)
-; P10-BE-NEXT:    std 4, 16(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: foo10:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI9_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI9_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, 16469
-; P8-LE-NEXT:    ori 4, 4, 7864
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: foo10:
 ; P9-LE:       # %bb.0: # %entry
 ; P9-LE-NEXT:    addis 4, 2, .LCPI9_0@toc@ha
 ; P9-LE-NEXT:    addi 4, 4, .LCPI9_0@toc@l
 ; P9-LE-NEXT:    lxv 0, 0(4)
-; P9-LE-NEXT:    lis 4, 16469
-; P9-LE-NEXT:    ori 4, 4, 7864
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: foo10:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 1079320248
 ; P10-LE-NEXT:    xxspltiw 0, 1079320248
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
 ; P10-LE-NEXT:    stxv 0, 0(3)
-; P10-LE-NEXT:    std 4, 16(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   store <4 x float> <float 0x400AA3D700000000, float 0x400AA3D700000000, float 0x400AA3D700000000, float 0x400AA3D700000000>, ptr %a, align 4
   %arrayidx4 = getelementptr inbounds float, ptr %a, i64 4
   store float 0x400AA3D700000000, ptr %arrayidx4, align 4
   %arrayidx5 = getelementptr inbounds float, ptr %a, i64 5
   store float 0x400AA3D700000000, ptr %arrayidx5, align 4
   ret void
 }

llvm/test/CodeGen/PowerPC/memset-tail.ll

entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 15, i64 25, i1 false)
   ret void
 }
 
 define dso_local void @memsetTailV1B8(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memsetTailV1B8:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    vspltisb 2, 15
-; P8-BE-NEXT:    lis 4, 3855
-; P8-BE-NEXT:    ori 4, 4, 3855
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stxsdx 34, 3, 4
 ; P8-BE-NEXT:    stxvw4x 34, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memsetTailV1B8:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, 3855
 ; P9-BE-NEXT:    xxspltib 0, 15
-; P9-BE-NEXT:    ori 4, 4, 3855
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memsetTailV1B8:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 252645135
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
-; P10-BE-NEXT:    std 4, 16(3)
 ; P10-BE-NEXT:    xxspltib 0, 15
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memsetTailV1B8:
 ; P8-LE:       # %bb.0: # %entry
-; P8-LE-NEXT:    lis 4, 3855
 ; P8-LE-NEXT:    vspltisb 2, 15
-; P8-LE-NEXT:    ori 4, 4, 3855
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
-; P8-LE-NEXT:    std 4, 16(3)
-; P8-LE-NEXT:    stxvd2x 34, 0, 3
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 0, 34
+; P8-LE-NEXT:    stxsdx 34, 3, 4
+; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memsetTailV1B8:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, 3855
 ; P9-LE-NEXT:    xxspltib 0, 15
-; P9-LE-NEXT:    ori 4, 4, 3855
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memsetTailV1B8:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 252645135
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
-; P10-LE-NEXT:    std 4, 16(3)
 ; P10-LE-NEXT:    xxspltib 0, 15
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 15, i64 24, i1 false)
   ret void
 }
 
 define dso_local void @memsetTailV1B7(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memsetTailV1B7:
 ; P8-BE:       # %bb.0: # %entry
-; P8-BE-NEXT:    lis 4, 3855
 ; P8-BE-NEXT:    vspltisb 2, 15
-; P8-BE-NEXT:    li 5, 15
-; P8-BE-NEXT:    ori 4, 4, 3855
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
-; P8-BE-NEXT:    stdx 4, 3, 5
+; P8-BE-NEXT:    li 4, 15
+; P8-BE-NEXT:    stxsdx 34, 3, 4
 ; P8-BE-NEXT:    stxvw4x 34, 0, 3
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memsetTailV1B7:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, 3855
-; P9-BE-NEXT:    li 5, 15
-; P9-BE-NEXT:    ori 4, 4, 3855
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
-; P9-BE-NEXT:    stdx 4, 3, 5
 ; P9-BE-NEXT:    xxspltib 0, 15
+; P9-BE-NEXT:    stfd 0, 15(3)
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memsetTailV1B7:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 252645135
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
-; P10-BE-NEXT:    pstd 4, 15(3), 0
 ; P10-BE-NEXT:    xxspltib 0, 15
+; P10-BE-NEXT:    mffprd 4, 0
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    pstd 4, 15(3), 0
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memsetTailV1B7:
 ; P8-LE:       # %bb.0: # %entry
-; P8-LE-NEXT:    lis 4, 3855
 ; P8-LE-NEXT:    vspltisb 2, 15
-; P8-LE-NEXT:    li 5, 15
-; P8-LE-NEXT:    ori 4, 4, 3855
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
-; P8-LE-NEXT:    stdx 4, 3, 5
-; P8-LE-NEXT:    stxvd2x 34, 0, 3
+; P8-LE-NEXT:    li 4, 15
+; P8-LE-NEXT:    xxswapd 0, 34
+; P8-LE-NEXT:    stxsdx 34, 3, 4
+; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memsetTailV1B7:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, 3855
-; P9-LE-NEXT:    li 5, 15
-; P9-LE-NEXT:    ori 4, 4, 3855
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
-; P9-LE-NEXT:    stdx 4, 3, 5
 ; P9-LE-NEXT:    xxspltib 0, 15
+; P9-LE-NEXT:    stfd 0, 15(3)
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memsetTailV1B7:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 252645135
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
-; P10-LE-NEXT:    pstd 4, 15(3), 0
 ; P10-LE-NEXT:    xxspltib 0, 15
+; P10-LE-NEXT:    mffprd 4, 0
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    pstd 4, 15(3), 0
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 15, i64 23, i1 false)
   ret void
 }
 
 define dso_local void @memsetTailV1B4(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memsetTailV1B4:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    vspltisb 2, 15
-; P8-BE-NEXT:    lis 4, 3855
-; P8-BE-NEXT:    ori 4, 4, 3855
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stxsiwx 34, 3, 4
 ; P8-BE-NEXT:    stxvw4x 34, 0, 3
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memsetTailV1B4:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, 3855
-; P9-BE-NEXT:    ori 4, 4, 3855
-; P9-BE-NEXT:    stw 4, 16(3)
 ; P9-BE-NEXT:    xxspltib 0, 15
+; P9-BE-NEXT:    li 4, 16
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memsetTailV1B4:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 252645135
-; P10-BE-NEXT:    stw 4, 16(3)
 ; P10-BE-NEXT:    xxspltib 0, 15
+; P10-BE-NEXT:    li 4, 16
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memsetTailV1B4:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    vspltisb 2, 15
-; P8-LE-NEXT:    lis 4, 3855
-; P8-LE-NEXT:    ori 4, 4, 3855
-; P8-LE-NEXT:    stw 4, 16(3)
-; P8-LE-NEXT:    stxvd2x 34, 0, 3
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    xxswapd 0, 34
+; P8-LE-NEXT:    stxsiwx 34, 3, 4
+; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memsetTailV1B4:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, 3855
-; P9-LE-NEXT:    ori 4, 4, 3855
-; P9-LE-NEXT:    stw 4, 16(3)
 ; P9-LE-NEXT:    xxspltib 0, 15
+; P9-LE-NEXT:    li 4, 16
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memsetTailV1B4:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 252645135
-; P10-LE-NEXT:    stw 4, 16(3)
 ; P10-LE-NEXT:    xxspltib 0, 15
+; P10-LE-NEXT:    li 4, 16
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    stxv 0, 0(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i32(ptr %p, i8 15, i32 20, i1 false)
   ret void
 }
 
 define dso_local void @memsetTailV1B3(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memsetTailV1B3:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    vspltisb 2, 15
-; P8-BE-NEXT:    lis 4, 3855
-; P8-BE-NEXT:    ori 4, 4, 3855
+; P8-BE-NEXT:    li 4, 15
+; P8-BE-NEXT:    stxsiwx 34, 3, 4
 ; P8-BE-NEXT:    stxvw4x 34, 0, 3
-; P8-BE-NEXT:    stw 4, 15(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memsetTailV1B3:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, 3855
-; P9-BE-NEXT:    ori 4, 4, 3855
-; P9-BE-NEXT:    stw 4, 15(3)
 ; P9-BE-NEXT:    xxspltib 0, 15
+; P9-BE-NEXT:    li 4, 15
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memsetTailV1B3:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 252645135
-; P10-BE-NEXT:    stw 4, 15(3)
 ; P10-BE-NEXT:    xxspltib 0, 15
+; P10-BE-NEXT:    li 4, 15
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memsetTailV1B3:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    vspltisb 2, 15
-; P8-LE-NEXT:    lis 4, 3855
-; P8-LE-NEXT:    ori 4, 4, 3855
-; P8-LE-NEXT:    stw 4, 15(3)
-; P8-LE-NEXT:    stxvd2x 34, 0, 3
+; P8-LE-NEXT:    li 4, 15
+; P8-LE-NEXT:    xxswapd 0, 34
+; P8-LE-NEXT:    stxsiwx 34, 3, 4
+; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memsetTailV1B3:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, 3855
-; P9-LE-NEXT:    ori 4, 4, 3855
-; P9-LE-NEXT:    stw 4, 15(3)
 ; P9-LE-NEXT:    xxspltib 0, 15
+; P9-LE-NEXT:    li 4, 15
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memsetTailV1B3:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 252645135
-; P10-LE-NEXT:    stw 4, 15(3)
 ; P10-LE-NEXT:    xxspltib 0, 15
+; P10-LE-NEXT:    li 4, 15
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    stxv 0, 0(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 15, i64 19, i1 false)
   ret void
 }
 
 define dso_local void @memsetTailV1B2(ptr nocapture noundef writeonly %p) local_unnamed_addr {
entry:
   ret void
 }
 
 define dso_local void @memset2TailV1B8(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memset2TailV1B8:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C3(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, -23131
-; P8-BE-NEXT:    ori 4, 4, 42405
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
+; P8-BE-NEXT:    stfd 0, 16(3)
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
-; P8-BE-NEXT:    std 4, 16(3)
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memset2TailV1B8:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, -23131
 ; P9-BE-NEXT:    xxspltib 0, 165
-; P9-BE-NEXT:    ori 4, 4, 42405
 ; P9-BE-NEXT:    stxv 0, 0(3)
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
-; P9-BE-NEXT:    std 4, 16(3)
+; P9-BE-NEXT:    stfd 0, 16(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memset2TailV1B8:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 2779096485
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
-; P10-BE-NEXT:    std 4, 16(3)
 ; P10-BE-NEXT:    xxspltib 0, 165
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    stfd 0, 16(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memset2TailV1B8:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI12_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI12_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, -23131
-; P8-LE-NEXT:    ori 4, 4, 42405
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
-; P8-LE-NEXT:    std 4, 16(3)
+; P8-LE-NEXT:    stfd 0, 16(3)
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memset2TailV1B8:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, -23131
 ; P9-LE-NEXT:    xxspltib 0, 165
-; P9-LE-NEXT:    ori 4, 4, 42405
 ; P9-LE-NEXT:    stxv 0, 0(3)
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
-; P9-LE-NEXT:    std 4, 16(3)
+; P9-LE-NEXT:    stfd 0, 16(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memset2TailV1B8:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 2779096485
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
-; P10-LE-NEXT:    std 4, 16(3)
 ; P10-LE-NEXT:    xxspltib 0, 165
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    stfd 0, 16(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 165, i64 24, i1 false)
   ret void
 }
 
 define dso_local void @memset2TailV1B7(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memset2TailV1B7:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C4(2) # %const.0
-; P8-BE-NEXT:    lis 5, -23131
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    ori 4, 5, 42405
-; P8-BE-NEXT:    li 5, 15
-; P8-BE-NEXT:    rldimi 4, 4, 32, 0
-; P8-BE-NEXT:    stdx 4, 3, 5
+; P8-BE-NEXT:    stfd 0, 15(3)
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memset2TailV1B7:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, -23131
-; P9-BE-NEXT:    li 5, 15
-; P9-BE-NEXT:    ori 4, 4, 42405
-; P9-BE-NEXT:    rldimi 4, 4, 32, 0
-; P9-BE-NEXT:    stdx 4, 3, 5
 ; P9-BE-NEXT:    xxspltib 0, 165
+; P9-BE-NEXT:    stfd 0, 15(3)
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memset2TailV1B7:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, 2779096485
-; P10-BE-NEXT:    rldimi 4, 4, 32, 0
-; P10-BE-NEXT:    pstd 4, 15(3), 0
 ; P10-BE-NEXT:    xxspltib 0, 165
+; P10-BE-NEXT:    mffprd 4, 0
 ; P10-BE-NEXT:    stxv 0, 0(3)
+; P10-BE-NEXT:    pstd 4, 15(3), 0
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memset2TailV1B7:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI13_0@toc@ha
-; P8-LE-NEXT:    lis 5, -23131
 ; P8-LE-NEXT:    addi 4, 4, .LCPI13_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    ori 4, 5, 42405
-; P8-LE-NEXT:    li 5, 15
-; P8-LE-NEXT:    rldimi 4, 4, 32, 0
-; P8-LE-NEXT:    stdx 4, 3, 5
+; P8-LE-NEXT:    stfd 0, 15(3)
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memset2TailV1B7:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, -23131
-; P9-LE-NEXT:    li 5, 15
-; P9-LE-NEXT:    ori 4, 4, 42405
-; P9-LE-NEXT:    rldimi 4, 4, 32, 0
-; P9-LE-NEXT:    stdx 4, 3, 5
 ; P9-LE-NEXT:    xxspltib 0, 165
+; P9-LE-NEXT:    stfd 0, 15(3)
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memset2TailV1B7:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, 2779096485
-; P10-LE-NEXT:    rldimi 4, 4, 32, 0
-; P10-LE-NEXT:    pstd 4, 15(3), 0
 ; P10-LE-NEXT:    xxspltib 0, 165
+; P10-LE-NEXT:    mffprd 4, 0
 ; P10-LE-NEXT:    stxv 0, 0(3)
+; P10-LE-NEXT:    pstd 4, 15(3), 0
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 165, i64 23, i1 false)
   ret void
 }
 
 define dso_local void @memset2TailV1B4(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memset2TailV1B4:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C5(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, -23131
-; P8-BE-NEXT:    ori 4, 4, 42405
-; P8-BE-NEXT:    stw 4, 16(3)
+; P8-BE-NEXT:    li 4, 16
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memset2TailV1B4:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, -23131
-; P9-BE-NEXT:    ori 4, 4, 42405
-; P9-BE-NEXT:    stw 4, 16(3)
 ; P9-BE-NEXT:    xxspltib 0, 165
+; P9-BE-NEXT:    li 4, 16
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memset2TailV1B4:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, -1515870811
-; P10-BE-NEXT:    stw 4, 16(3)
 ; P10-BE-NEXT:    xxspltib 0, 165
+; P10-BE-NEXT:    li 4, 16
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memset2TailV1B4:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI14_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI14_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, -23131
-; P8-LE-NEXT:    ori 4, 4, 42405
-; P8-LE-NEXT:    stw 4, 16(3)
+; P8-LE-NEXT:    li 4, 16
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memset2TailV1B4:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, -23131
-; P9-LE-NEXT:    ori 4, 4, 42405
-; P9-LE-NEXT:    stw 4, 16(3)
 ; P9-LE-NEXT:    xxspltib 0, 165
+; P9-LE-NEXT:    li 4, 16
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memset2TailV1B4:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, -1515870811
-; P10-LE-NEXT:    stw 4, 16(3)
 ; P10-LE-NEXT:    xxspltib 0, 165
+; P10-LE-NEXT:    li 4, 16
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    stxv 0, 0(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i32(ptr %p, i8 165, i32 20, i1 false)
   ret void
 }
 
 define dso_local void @memset2TailV1B3(ptr nocapture noundef writeonly %p) local_unnamed_addr {
 ; P8-BE-LABEL: memset2TailV1B3:
 ; P8-BE:       # %bb.0: # %entry
 ; P8-BE-NEXT:    ld 4, L..C6(2) # %const.0
 ; P8-BE-NEXT:    lxvw4x 0, 0, 4
-; P8-BE-NEXT:    lis 4, -23131
-; P8-BE-NEXT:    ori 4, 4, 42405
-; P8-BE-NEXT:    stw 4, 15(3)
+; P8-BE-NEXT:    li 4, 15
+; P8-BE-NEXT:    stfiwx 0, 3, 4
 ; P8-BE-NEXT:    stxvw4x 0, 0, 3
 ; P8-BE-NEXT:    blr
 ;
 ; P9-BE-LABEL: memset2TailV1B3:
 ; P9-BE:       # %bb.0: # %entry
-; P9-BE-NEXT:    lis 4, -23131
-; P9-BE-NEXT:    ori 4, 4, 42405
-; P9-BE-NEXT:    stw 4, 15(3)
 ; P9-BE-NEXT:    xxspltib 0, 165
+; P9-BE-NEXT:    li 4, 15
+; P9-BE-NEXT:    stfiwx 0, 3, 4
 ; P9-BE-NEXT:    stxv 0, 0(3)
 ; P9-BE-NEXT:    blr
 ;
 ; P10-BE-LABEL: memset2TailV1B3:
 ; P10-BE:       # %bb.0: # %entry
-; P10-BE-NEXT:    pli 4, -1515870811
-; P10-BE-NEXT:    stw 4, 15(3)
 ; P10-BE-NEXT:    xxspltib 0, 165
+; P10-BE-NEXT:    li 4, 15
+; P10-BE-NEXT:    stfiwx 0, 3, 4
 ; P10-BE-NEXT:    stxv 0, 0(3)
 ; P10-BE-NEXT:    blr
 ;
 ; P8-LE-LABEL: memset2TailV1B3:
 ; P8-LE:       # %bb.0: # %entry
 ; P8-LE-NEXT:    addis 4, 2, .LCPI15_0@toc@ha
 ; P8-LE-NEXT:    addi 4, 4, .LCPI15_0@toc@l
 ; P8-LE-NEXT:    lxvd2x 0, 0, 4
-; P8-LE-NEXT:    lis 4, -23131
-; P8-LE-NEXT:    ori 4, 4, 42405
-; P8-LE-NEXT:    stw 4, 15(3)
+; P8-LE-NEXT:    li 4, 15
+; P8-LE-NEXT:    stfiwx 0, 3, 4
 ; P8-LE-NEXT:    stxvd2x 0, 0, 3
 ; P8-LE-NEXT:    blr
 ;
 ; P9-LE-LABEL: memset2TailV1B3:
 ; P9-LE:       # %bb.0: # %entry
-; P9-LE-NEXT:    lis 4, -23131
-; P9-LE-NEXT:    ori 4, 4, 42405
-; P9-LE-NEXT:    stw 4, 15(3)
 ; P9-LE-NEXT:    xxspltib 0, 165
+; P9-LE-NEXT:    li 4, 15
+; P9-LE-NEXT:    stfiwx 0, 3, 4
 ; P9-LE-NEXT:    stxv 0, 0(3)
 ; P9-LE-NEXT:    blr
 ;
 ; P10-LE-LABEL: memset2TailV1B3:
 ; P10-LE:       # %bb.0: # %entry
-; P10-LE-NEXT:    pli 4, -1515870811
-; P10-LE-NEXT:    stw 4, 15(3)
 ; P10-LE-NEXT:    xxspltib 0, 165
+; P10-LE-NEXT:    li 4, 15
+; P10-LE-NEXT:    stfiwx 0, 3, 4
 ; P10-LE-NEXT:    stxv 0, 0(3)
 ; P10-LE-NEXT:    blr
 entry:
   tail call void @llvm.memset.p0.i64(ptr %p, i8 165, i64 19, i1 false)
   ret void
 }
 
 define dso_local void @memset2TailV1B2(ptr nocapture noundef writeonly %p) local_unnamed_addr {