[PowerPC] common chains to reuse offsets to reduce register pressure

[shchenz]

Summary

//    common multiple chains for the load/stores with same offsets in the loop, 
//    so that we can reuse the offsets and reduce the register pressure in the                                                                         
//    loop. This transformation can also increase the loop ILP as now each chain
//    uses its own loop induction add/addi. But this will increase the number of
//    add/addi in the loop.                                                     
//
//    char *p;                                                                  
//    A1 = p + base1                                                                                                                                   
//    A2 = p + base1 + offset                                                   
//    B1 = p + base2                                                            
//    B2 = p + base2 + offset                                                   
//                                                                              
//    for (int i = 0; i < n; i++)                                               
//      unsigned long x1 = *(unsigned long *)(A1 + i);                          
//      unsigned long x2 = *(unsigned long *)(A2 + i)                           
//      unsigned long x3 = *(unsigned long *)(B1 + i);                          
//      unsigned long x4 = *(unsigned long *)(B2 + i);                          
//    }                                                                         
//                                                                              
//    to look like this:                                                        
//                                                                                  
//    A1_new = p + base1 // chain 1                                                 
//    B1_new = p + base2 // chain 2, now inside the loop, common offset is          
//                       // reused.                                                 
//                                                                                  
//    for (long long i = 0; i < n; i+=count) {                                      
//      unsigned long x1 = *(unsigned long *)(A1_new + i);                          
//      unsigned long x2 = *(unsigned long *)((A1_new + i) + offset);               
//      unsigned long x3 = *(unsigned long *)(B1_new + i);                          
//      unsigned long x4 = *(unsigned long *)((B1_new + i) + offset);               
//    }

Found some improvements for our internal benchmarks.

[qiucf]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

127

Better as EnableChainCommoning?

[shchenz]

address @qiucf comments and rebase

[shchenz]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

127

Good idea.

[shchenz]

rebase

[shchenz]

For a better review, I will split the patch into two patches:
1: NFC patch for the function outlining, like rewriteForBase and rewriteForBucketElement;
2: functionality change for chain common

[shchenz]

rebase on D110314

[jsji]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

66

Can we avoid using ' in examples?

405

treat it with? treat it as?

480

Why this can not reuse collectCandidates?

486

We already collected both Dform and DQform buckets before, can we reuse some info to do early exit?

514

TotalCount? ReusableOffsetCount?

515

FirstGroupCount? NewGroupCount?

517

SawSeperator? SawDifferentOffset?

519

Do we have assumption about the order of Element offset? Can we add comments

529

How about 2 reusable offset in 20 offsets? Maybe we should introduce a heuristic to control whether we want to skip the bucket? eg: if the ratio of reusable is very low?

532

// Only one offset?

533

Why sqrt(EleNum)?

552

This is common to 552, can we just us different ChainNum w w/o SawSeperator?

556

Why we need this check here?

593

Can we introduce an option to control, and just set 4 to be the default?

Also, why we can't push this check into prepareBasesForCommoningChains?

601

Can we loop through BBChanged only?

618

How often we will get unsafe offsets? Can we just do early exit in the main loop below?

636

pistart? Can we use a more meaningful name.

[shchenz]

address @jsji comments

[shchenz]

Thanks for your review. @jsji Updated accordingly.

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

486

Good idea. We can share the info among all forms. I split this into a new patch D112196.

529

I added a new threshold MaxVarsChainCommon in the new patch which will prevent from commoning too many chains.

533

The minimal for (EleNum/x + x) (1 <= x <= EleNum and x is the chain number) should be when x == sqrt(EleNum)?

552

Maybe we can revisit this comment after I add more comments to this function to make it clear.

556

Suppose there are two chains, we need to make sure, each diff between two adjacent elements is the same among chains.
For example,

after we divided the bucket to two chains A {baseA, offset1, offset2, offset3, offset4}, B {baseB, offset5, offset6, offset7, offset8},
we need to make sure offset1 = offset5, offset2 == offset6, offset3 = offset7, offset4 = offset8.

So we can use two bases and 4 reused offsets.

601

yes, I think we can and we should. I will post another patch for this NFC change as this usage is also existing in updateFormPrep and dispFormPrep

618

I am not sure how often we get unsafe offset. Before we expand a SCEV, it is safe to call this function first. If necessary, I will do more investigation later to confirm for what kind of case, isSafeToExpandis needed

[jsji]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

67

offset is reused ? common offset is re-used?

71

Should we use ((A1_new + i) + offset ) to be clearer?

395

isChainCommoningCandidate , to be aligned with isDSFormCandidate etc.

461

Why we have this limit check here, but not in addOneCandidate?

Also we should at least emit some debug log if we are really discarding candidate due to bucket limit here.

464

This should be checked in collectCandiate, as isValidCandidate.

473

Can we also abstract this check so that we can also reuse addOneCandidate to do this.

Something like:

for (auto &B : Buckets) {
   const SCEV *Diff = SE->getMinusSCEV(LSCEV, B.BaseSCEV);
   if ( const auto *Diff = isValidDiff(Diff, LSCEV, B.BaseSCEV)) {
     B.Elements.push_back(BucketElement(Diff, MemI));
     FoundBucket = true;
     break;
   }
 }

then we use isValidConstantDiff for others, but isValidChainCommoningDiff for this.

isValidConstantDiff(Diff, LSCEV, B.BaseSCEV) ={
return dyn_cast<SCEVConstant>(Diff)
}

isValidChainCommoningDiff(Diff, LSCEV, B.BaseSCEV) ={

  assert(LSCEV && "Invalid SCEV for Ptr value.");

  // Don't mess up previous dform prepare.
  if (isa<SCEVConstant>(LSCEV))
    return null_ptr;

  // A single integer type offset.
  if (isa<SCEVUnknown>(LSCEV) && LSCEV->getType()->isIntegerTy())
    return Diff;

  const SCEVNAryExpr *ASCEV = dyn_cast<SCEVNAryExpr>(LSCEV);
  if (!ASCEV)
    return null_ptr;

  for (const SCEV *Op : ASCEV->operands())
    if (!Op->getType()->isIntegerTy())
      return null_ptr;

  return Diff;


}

486

D112196 looks good. But I think we can still do more for this? eg: If both Dform and DQform buckets are empty, then there is no point trying to run this commoning either?

558

How about this?

unsigned ChainNum=FirstOffsetReusedCount / FirstOffsetReusedCountInFirstChain;
if (!SawChainSeparater) 
  ChainNum = (unsigned)sqrt(EleNum);

 CBucket.ChainSize = (unsigned)(EleNum / ChainNum);

 // If this is not a perfect chain(eg: all elements can be put inside
 // commoning chains.), skip now.
 if (CBucket.ChainSize * ChainNum != EleNum)
     return false;

 if (SawChainSeparater) {
 // Check that the offset seqs are the same for all chains?
     for (unsigned i = 1; i < CBucket.ChainSize; i++)
         for (unsigned j = 1; j < ChainNum; j++)
            if (CBucket.Elements[i].Offset !=
                SE->getMinusSCEV(CBucket.Elements[i + j * CBucket.ChainSize].Offset,
                          CBucket.Elements[j * CBucket.ChainSize].Offset))
            return false;

  }

 for (unsigned i = 0; i < ChainNum; i++)
   CBucket.ChainBases.push_back(CBucket.Elements[i * CBucket.ChainSize]);

576

Not all elements?

580

// Check that the offset seqs are the same for all chains?

902

Since we are reusing collectCandidates, this check can be moved out to around line 1488.

930

Why we can't pass isValidChainCommoningCandidate as isValidCandate (yes, need to add one more LSCEV parameter to function prototype) , and pass`addOneCandidateForChainCommoning` as addOneCandiate function too?

Then we don't need the IsChainCommoning bool parameter and conditional check here.

[jsji]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

473

isValidChainCommoningDiff(Diff, LSCEV, B.BaseSCEV) ={


  assert(LSCEV && "Invalid SCEV for Ptr value.");

  if (cast<SCEVAddRecExpr>(B.BaseSCEV)->getStepRecurrence(*SE) !=
        cast<SCEVAddRecExpr>(LSCEV)->getStepRecurrence(*SE))
      return null_ptr;

  // Don't mess up previous dform prepare.
  if (isa<SCEVConstant>(LSCEV))
    return null_ptr;

  // A single integer type offset.
  if (isa<SCEVUnknown>(LSCEV) && LSCEV->getType()->isIntegerTy())
    return Diff;

  const SCEVNAryExpr *ASCEV = dyn_cast<SCEVNAryExpr>(LSCEV);
  if (!ASCEV)
    return null_ptr;

  for (const SCEV *Op : ASCEV->operands())
    if (!Op->getType()->isIntegerTy())
      return null_ptr;

  return Diff;


}

[shchenz]

address @jsji comments

[shchenz]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

486

Not exactly, ds/dq forms require the diff between elements must be constants, but we can prepare for non-constant diffs for chain commoning.

[jsji]

LGTM. Thanks for working on this.

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

153

Address clang-format warning please.

532

Can we name this different from line 1019? both are "loopprepare"?

880

This is a new check for updateform/d/dqform, make sure it is intended.

[shchenz]

Thanks for your review. @jsji

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

880

Yes, this is required for chain common but not needed for update/d/dqform rewrite.

[ro]

This patch broke the Solaris build:

/vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp: In member function ‘bool {anonymous}::PPCLoopInstrFormPrep::prepareBasesForCommoningChains({anonymous}::Bucket&)’:
/vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp:497:37: error: call of overloaded ‘sqrt(unsigned int&)’ is ambiguous
  497 |     ChainNum = (unsigned)sqrt(EleNum);
      |                                     ^
In file included from /vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/math.h:24,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/bits/std_abs.h:40,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/cstdlib:77,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/bits/stl_algo.h:59,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/algorithm:62,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/Hashing.h:51,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/Optional.h:18,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/STLExtras.h:19,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCFrameLowering.h:15,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCSubtarget.h:16,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp:79:
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:220:21: note: candidate: ‘long double std::sqrt(long double)’
  220 |  inline long double sqrt(long double __X) { return __sqrtl(__X); }
      |                     ^~~~
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:186:15: note: candidate: ‘float std::sqrt(float)’
  186 |  inline float sqrt(float __X) { return __sqrtf(__X); }
      |               ^~~~
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:74:15: note: candidate: ‘double std::sqrt(double)’
   74 | extern double sqrt __P((double));
      |               ^~~~

Can be fixed e.g. by casting EleNum to double.

[shchenz]

In D108750#3095793, @ro wrote:

This patch broke the Solaris build:

/vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp: In member function ‘bool {anonymous}::PPCLoopInstrFormPrep::prepareBasesForCommoningChains({anonymous}::Bucket&)’:
/vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp:497:37: error: call of overloaded ‘sqrt(unsigned int&)’ is ambiguous
  497 |     ChainNum = (unsigned)sqrt(EleNum);
      |                                     ^
In file included from /vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/math.h:24,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/bits/std_abs.h:40,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/cstdlib:77,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/bits/stl_algo.h:59,
                 from /vol/gcc-10/.11.4-gas-64/include/c++/10.1.0/algorithm:62,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/Hashing.h:51,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/Optional.h:18,
                 from /vol/llvm/src/llvm-project/dist/llvm/include/llvm/ADT/STLExtras.h:19,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCFrameLowering.h:15,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCSubtarget.h:16,
                 from /vol/llvm/src/llvm-project/dist/llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp:79:
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:220:21: note: candidate: ‘long double std::sqrt(long double)’
  220 |  inline long double sqrt(long double __X) { return __sqrtl(__X); }
      |                     ^~~~
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:186:15: note: candidate: ‘float std::sqrt(float)’
  186 |  inline float sqrt(float __X) { return __sqrtf(__X); }
      |               ^~~~
/vol/gcc-10/.11.4-gas-64/lib/gcc/amd64-pc-solaris2.11/10.1.0/include-fixed/iso/math_iso.h:74:15: note: candidate: ‘double std::sqrt(double)’
   74 | extern double sqrt __P((double));
      |               ^~~~

Can be fixed e.g. by casting EleNum to double.

Thanks for reporting. 7591d2103222d712b589600a7f7bc19683152bdd is committed

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

 //    for (int i = 0; i < n; ++i)
 //      array[i] = c;
 //
 //    to look like this:
 //
 //    T *p = array[-1];
 //    for (int i = 0; i < n; ++i)
 //      *++p = c;
+//
+// 3: common multiple chains for the load/stores with same offsets in the loop,
+//    so that we can reuse the offsets and reduce the register pressure in the
+//    loop. This transformation can also increase the loop ILP as now each chain
+//    uses its own loop induction add/addi. But this will increase the number of
+//    add/addi in the loop.
+//
+//    Generically, this means transforming loops like this:
+//
+//    char *p;
+//    A1 = p + base1
+//    A2 = p + base1 + offset
+//    B1 = p + base2
+//    B2 = p + base2 + offset
+//
+//    for (int i = 0; i < n; i++)
+//      unsigned long x1 = *(unsigned long *)(A1 + i);
+//      unsigned long x2 = *(unsigned long *)(A2 + i)
+//      unsigned long x3 = *(unsigned long *)(B1 + i);
+//      unsigned long x4 = *(unsigned long *)(B2 + i);
+//    }
+//
+//    to look like this:
+//
+//    A1’ = p + base1 // chain 1
+//    B1’ = p + base2 // chain 2, now inside the loop, offset is reused.
+//
+//    for (long long i = 0; i < n; i+=count) {
+//      unsigned long x1 = *(unsigned long *)(A1’ + i);
+//      unsigned long x2 = *(unsigned long *)(A1’ + offset + i);
+//      unsigned long x3 = *(unsigned long *)(B1’ + i);
+//      unsigned long x4 = *(unsigned long *)(B1’ + offset + i);
+//    }
 //===----------------------------------------------------------------------===//
 
 #include "PPC.h"
 #include "PPCSubtarget.h"
 #include "PPCTargetMachine.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
static cl::opt<unsigned> MaxVarsPrep("ppc-formprep-max-vars",
                                  cl::Hidden, cl::init(24),
   cl::desc("Potential common base number threshold per function for PPC loop "
            "prep"));
 
 static cl::opt<bool> PreferUpdateForm("ppc-formprep-prefer-update",
                                  cl::init(true), cl::Hidden,
   cl::desc("prefer update form when ds form is also a update form"));
 
+static cl::opt<bool>
+    DoChainCommoning("ppc-formprep-chain-commoning", cl::init(true), cl::Hidden,
+                     cl::desc("Do chain commoning in PPC loop prepare pass."));
+
 // Sum of following 3 per loop thresholds for all loops can not be larger
 // than MaxVarsPrep.
 // now the thresholds for each kind prep are exterimental values on Power9.
 static cl::opt<unsigned> MaxVarsUpdateForm("ppc-preinc-prep-max-vars",
                                  cl::Hidden, cl::init(3),
   cl::desc("Potential PHI threshold per loop for PPC loop prep of update "
            "form"));
 
 static cl::opt<unsigned> MaxVarsDSForm("ppc-dsprep-max-vars",
                                  cl::Hidden, cl::init(3),
   cl::desc("Potential PHI threshold per loop for PPC loop prep of DS form"));
 
 static cl::opt<unsigned> MaxVarsDQForm("ppc-dqprep-max-vars",
                                  cl::Hidden, cl::init(8),
   cl::desc("Potential PHI threshold per loop for PPC loop prep of DQ form"));
 
 
 // If would not be profitable if the common base has only one load/store, ISEL
 // should already be able to choose best load/store form based on offset for
 // single load/store. Set minimal profitable value default to 2 and make it as
 // an option.
 static cl::opt<unsigned> DispFormPrepMinThreshold("ppc-dispprep-min-threshold",
                                     cl::Hidden, cl::init(2),
   cl::desc("Minimal common base load/store instructions triggering DS/DQ form "
            "preparation"));
 
 STATISTIC(PHINodeAlreadyExistsUpdate, "PHI node already in pre-increment form");
 STATISTIC(PHINodeAlreadyExistsDS, "PHI node already in DS form");
 STATISTIC(PHINodeAlreadyExistsDQ, "PHI node already in DQ form");
 STATISTIC(DSFormChainRewritten, "Num of DS form chain rewritten");
 STATISTIC(DQFormChainRewritten, "Num of DQ form chain rewritten");
 STATISTIC(UpdFormChainRewritten, "Num of update form chain rewritten");
 
 namespace {
   struct BucketElement {
-    BucketElement(const SCEVConstant *O, Instruction *I) : Offset(O), Instr(I) {}
+    BucketElement(const SCEV *O, Instruction *I) : Offset(O), Instr(I) {}
     BucketElement(Instruction *I) : Offset(nullptr), Instr(I) {}
 
-    const SCEVConstant *Offset;
+    const SCEV *Offset;
     Instruction *Instr;
   };
 
   struct Bucket {
-    Bucket(const SCEV *B, Instruction *I) : BaseSCEV(B),
-                                            Elements(1, BucketElement(I)) {}
+    Bucket(const SCEV *B, Instruction *I)
+        : BaseSCEV(B), Elements(1, BucketElement(I)) {
+      ChainSize = 0;
+    }
 
+    // The base of the whole bucket.
     const SCEV *BaseSCEV;
+
+    // All elements in the bucket. In the bucket, the element with the BaseSCEV
+    // has no offset and all other elements are stored as offsets to the
+    // BaseSCEV.
     SmallVector<BucketElement, 16> Elements;
+
+    // The potential chains size. This is used for chain commoning only.
+    unsigned ChainSize;
+
+    // The base for each potential chain. This is used for chain commoning only.
+    SmallVector<BucketElement, 16> ChainBases;
   };
 
   // "UpdateForm" is not a real PPC instruction form, it stands for dform
   // load/store with update like ldu/stdu, or Prefetch intrinsic.
   // For DS form instructions, their displacements must be multiple of 4.
   // For DQ form instructions, their displacements must be multiple of 16.
   enum InstrForm { UpdateForm = 1, DSForm = 4, DQForm = 16 };
 
private:
     bool alreadyPrepared(Loop *L, Instruction *MemI,
                          const SCEV *BasePtrStartSCEV,
                          const SCEV *BasePtrIncSCEV, InstrForm Form);
 
     /// Get the value which defines the increment SCEV \p BasePtrIncSCEV.
     Value *getPreparedIncNode(Loop *L, Instruction *MemI,
                               const SCEV *BasePtrIncSCEV);
 
+    /// Collect chain commoning load/store candidates in Loop \p L.
+    SmallVector<Bucket, 16> collectCandidatesForChainCommoning(Loop *L);
+
+    /// Add a candidate to candidates \p Buckets for chain commoning.
+    void addOneCandidateForChainCommoning(Instruction *MemI, const SCEV *LSCEV,
+                                          SmallVector<Bucket, 16> &Buckets);
+
+    /// Common chains to reuse offsets for a loop to reduce register pressure.
+    bool chainCommoning(Loop *L, SmallVector<Bucket, 16> &Buckets);
+
+    /// Find out the potential commoning chains and their bases.
+    bool prepareBasesForCommoningChains(Bucket &BucketChain);
+
+    /// Rewrite load/store according to the common chains.
+    bool
+    rewriteLoadStoresForCommoningChains(Loop *L, Bucket &Bucket,
+                                        SmallSet<BasicBlock *, 16> &BBChanged);
+
     /// Collect condition matched(\p isValidCandidate() returns true)
     /// candidates in Loop \p L.
     SmallVector<Bucket, 16> collectCandidates(
         Loop *L,
         std::function<bool(const Instruction *, const Value *, const Type *)>
             isValidCandidate,
         unsigned MaxCandidateNum);
 
private:
     /// Return false if no base element found, otherwise return true.
     bool prepareBaseForUpdateFormChain(Bucket &BucketChain);
 
     /// Rewrite load/store instructions in \p BucketChain according to
     /// preparation.
     bool rewriteLoadStores(Loop *L, Bucket &BucketChain,
                            SmallSet<BasicBlock *, 16> &BBChanged,
                            InstrForm Form);
+
+    /// Rewrite for the base load/store of a chain.
+    std::pair<Instruction *, Instruction *>
+    rewriteForBase(Loop *L, const SCEVAddRecExpr *BasePtrSCEV,
+                   Instruction *BaseMemI, bool CanPreInc, InstrForm Form,
+                   SCEVExpander &SCEVE, SmallPtrSet<Value *, 16> &DeletedPtrs);
+
+    /// Rewrite for the other load/stores of a chain according to the new \p
+    /// Base.
+    Instruction *
+    rewriteForBucketElement(std::pair<Instruction *, Instruction *> Base,
+                            const BucketElement &Element, Value *OffToBase,
+                            SmallPtrSet<Value *, 16> &DeletedPtrs);
   };
 
 } // end anonymous namespace
 
 char PPCLoopInstrFormPrep::ID = 0;
 static const char *name = "Prepare loop for ppc preferred instruction forms";
 INITIALIZE_PASS_BEGIN(PPCLoopInstrFormPrep, DEBUG_TYPE, name, false, false)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)

 static std::string getInstrName(const Value *I, StringRef Suffix) {
   assert(I && "Invalid paramater!");
   if (I->hasName())
     return (I->getName() + Suffix).str();
   else
     return "";
 }
 
-static Value *GetPointerOperand(Value *MemI) {
+static Value *getPtrOperand(Value *MemI) {
   if (LoadInst *LMemI = dyn_cast<LoadInst>(MemI)) {
     return LMemI->getPointerOperand();
   } else if (StoreInst *SMemI = dyn_cast<StoreInst>(MemI)) {
     return SMemI->getPointerOperand();
   } else if (IntrinsicInst *IMemI = dyn_cast<IntrinsicInst>(MemI)) {
     if (IMemI->getIntrinsicID() == Intrinsic::prefetch ||
         IMemI->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp)
       return IMemI->getArgOperand(0);
bool PPCLoopInstrFormPrep::runOnFunction(Function &F) {
 
   for (auto I = LI->begin(), IE = LI->end(); I != IE; ++I)
     for (auto L = df_begin(*I), LE = df_end(*I); L != LE; ++L)
       MadeChange |= runOnLoop(*L);
 
   return MadeChange;
 }
 
+// check if the SCEV is only with one ptr operand in its start, so that we can
+// use that start as a chain separator.
+static bool isValidChainCommoningCandidate(const SCEV *LSCEV) {
+  const SCEVAddRecExpr *ARSCEV = cast<SCEVAddRecExpr>(LSCEV);
+  if (!ARSCEV)
+    return false;
+
+  if (!ARSCEV->isAffine())
+    return false;
+
+  const SCEV *Start = ARSCEV->getStart();
+
+  // A single pointer. We can treat it with offset 0.
+  if (isa<SCEVUnknown>(Start) && Start->getType()->isPointerTy())
+    return true;
+
+  const SCEVAddExpr *ASCEV = dyn_cast<SCEVAddExpr>(Start);
+
+  // We need a SCEVAddExpr to include both base and offset.
+  if (!ASCEV)
+    return false;
+
+  // Make sure there is only one pointer operand(base) and all other operands
+  // are integer type.
+  bool SawPointer = false;
+  for (const SCEV *Op : ASCEV->operands()) {
+    if (Op->getType()->isPointerTy()) {
+      if (SawPointer)
+        return false;
+      SawPointer = true;
+    } else if (!Op->getType()->isIntegerTy())
+      return false;
+  }
+
+  return SawPointer;
+}
+
+// Make sure the diff between the base and new candidate is required type.
+static bool isValidChainCommoningDiff(const SCEV *LSCEV) {
+  assert(LSCEV && "Invalid SCEV for Ptr value.");
+
+  // Don't mess up previous dform prepare.
+  if (isa<SCEVConstant>(LSCEV))
+    return false;
+
+  // A single integer type offset.
+  if (isa<SCEVUnknown>(LSCEV) && LSCEV->getType()->isIntegerTy())
+    return true;
+
+  const SCEVNAryExpr *ASCEV = dyn_cast<SCEVNAryExpr>(LSCEV);
+  if (!ASCEV)
+    return false;
+
+  for (const SCEV *Op : ASCEV->operands())
+    if (!Op->getType()->isIntegerTy())
+      return false;
+
+  return true;
+}
+
+void PPCLoopInstrFormPrep::addOneCandidateForChainCommoning(
+    Instruction *MemI, const SCEV *LSCEV, SmallVector<Bucket, 16> &Buckets) {
+  assert((MemI && getPtrOperand(MemI)) &&
+         "Candidate should be a memory instruction.");
+  assert(LSCEV && "Invalid SCEV for Ptr value.");
+
+  if (!isValidChainCommoningCandidate(LSCEV))
+    return;
+
+  bool FoundBucket = false;
+  for (auto &B : Buckets) {
+    if (cast<SCEVAddRecExpr>(B.BaseSCEV)->getStepRecurrence(*SE) !=
+        cast<SCEVAddRecExpr>(LSCEV)->getStepRecurrence(*SE))
+      continue;
+    const SCEV *Diff = SE->getMinusSCEV(LSCEV, B.BaseSCEV);
+    if (isValidChainCommoningDiff(Diff)) {
+      B.Elements.push_back(BucketElement(Diff, MemI));
+      FoundBucket = true;
+      break;
+    }
+  }
+
+  if (!FoundBucket)
+    Buckets.push_back(Bucket(LSCEV, MemI));
+}
+
+SmallVector<Bucket, 16>
+PPCLoopInstrFormPrep::collectCandidatesForChainCommoning(Loop *L) {
+  SmallVector<Bucket, 16> Buckets;
+
+  if (!DoChainCommoning)
+    return Buckets;
+
+  for (const auto &BB : L->blocks())
+    for (auto &J : *BB) {
+      Value *PtrValue = getPtrOperand(&J);
+      if (!PtrValue)
+        continue;
+
+      unsigned PtrAddrSpace = PtrValue->getType()->getPointerAddressSpace();
+      if (PtrAddrSpace)
+        continue;
+
+      if (L->isLoopInvariant(PtrValue))
+        continue;
+
+      const SCEV *LSCEV = SE->getSCEVAtScope(PtrValue, L);
+      const SCEVAddRecExpr *LARSCEV = dyn_cast<SCEVAddRecExpr>(LSCEV);
+      if (!LARSCEV || LARSCEV->getLoop() != L)
+        continue;
+
+      addOneCandidateForChainCommoning(&J, LSCEV, Buckets);
+    }
+  return Buckets;
+}
+
+bool PPCLoopInstrFormPrep::prepareBasesForCommoningChains(Bucket &CBucket) {
+  // It is profitable to have at least 4 elements in the chain bucket.
+  assert(CBucket.Elements.size() >= 4 && "Not a candidate bucket!\n");
+
+  const SCEV *Offset = CBucket.Elements[1].Offset;
+  unsigned TotalCount = 1;
+  unsigned FirstGroupCount = 1;
+  unsigned EleNum = CBucket.Elements.size();
+  bool SawSeparater = false;
+  for (unsigned j = 2; j != EleNum; ++j) {
+    if (SE->getMinusSCEV(CBucket.Elements[j].Offset,
+                         CBucket.Elements[j - 1].Offset) == Offset) {
+      if (!SawSeparater)
+        FirstGroupCount++;
+      TotalCount++;
+    } else
+      SawSeparater = true;
+  }
+
+  // No reuseable offset, skip this bucket.
+  if (TotalCount == 1)
+    return false;
+
+  // All elements are increased by Offset.
+  // The number of new bases should both be sqrt(EleNum).
+  if (!SawSeparater) {
+    unsigned ChainNum = (unsigned)sqrt(EleNum);
+    CBucket.ChainSize = (unsigned)(EleNum / ChainNum);
+
+    // If this is not a perfect chain(eg: all elements can be put inside
+    // commoning chains.), skip now.
+    if (CBucket.ChainSize * ChainNum != EleNum)
+      return false;
+
+    for (unsigned i = 0; i < ChainNum; i++)
+      CBucket.ChainBases.push_back(CBucket.Elements[i * CBucket.ChainSize]);
+    return true;
+  }
+
+  unsigned ChainNum = TotalCount / FirstGroupCount;
+  CBucket.ChainSize = EleNum / ChainNum;
+
+  // All Elements can be put inside commoning chains.
+  if (CBucket.ChainSize * ChainNum != EleNum)
+    return false;
+
+  // Check each chain has same offsets for all elements.
+  for (unsigned i = 1; i < CBucket.ChainSize; i++)
+    for (unsigned j = 1; j < ChainNum; j++)
+      if (CBucket.Elements[i].Offset !=
+          SE->getMinusSCEV(CBucket.Elements[i + j * CBucket.ChainSize].Offset,
+                           CBucket.Elements[j * CBucket.ChainSize].Offset))
+        return false;
+
+  for (unsigned i = 0; i < ChainNum; i++)
+    CBucket.ChainBases.push_back(CBucket.Elements[i * CBucket.ChainSize]);
+
+  return true;
+}
+
+bool PPCLoopInstrFormPrep::chainCommoning(Loop *L,
+                                          SmallVector<Bucket, 16> &Buckets) {
+  bool MadeChange = false;
+
+  if (Buckets.empty())
+    return MadeChange;
+
+  SmallSet<BasicBlock *, 16> BBChanged;
+
+  for (auto &Bucket : Buckets) {
+    // The minimal size for profitable chain commoning:
+    // A1 = base + offset1
+    // A2 = base + offset2 (offset2 - offset1 = X)
+    // A3 = base + offset3
+    // A4 = base + offset4 (offset4 - offset3 = X)
+    // ======>
+    // base1 = base + offset1
+    // base2 = base + offset3
+    // A1 = base1
+    // A2 = base1 + X
+    // A3 = base2
+    // A4 = base2 + X
+    //
+    // There is benefit because of reuse of offest 'X'.
+    if (Bucket.Elements.size() < 4)
+      continue;
+
+    if (prepareBasesForCommoningChains(Bucket))
+      MadeChange |= rewriteLoadStoresForCommoningChains(L, Bucket, BBChanged);
+  }
+
+  if (MadeChange)
+    for (auto &BB : L->blocks())
+      if (BBChanged.count(BB))
+        DeleteDeadPHIs(BB);
+  return MadeChange;
+}
+
+bool PPCLoopInstrFormPrep::rewriteLoadStoresForCommoningChains(
+    Loop *L, Bucket &Bucket, SmallSet<BasicBlock *, 16> &BBChanged) {
+  bool MadeChange = false;
+
+  assert(Bucket.Elements.size() ==
+             Bucket.ChainBases.size() * Bucket.ChainSize &&
+         "invalid bucket for chain commoning!\n");
+  SmallPtrSet<Value *, 16> DeletedPtrs;
+
+  // Make sure each offset is able to expand.
+  for (unsigned Idx = 1; Idx < Bucket.ChainSize; ++Idx)
+    if (!isSafeToExpand(Bucket.Elements[Idx].Offset, *SE))
+      return MadeChange;
+
+  // Make sure each base is able to expand.
+  for (unsigned Idx = 0; Idx < Bucket.ChainBases.size(); ++Idx) {
+    const SCEV *BaseSCEV =
+        Idx ? SE->getAddExpr(Bucket.BaseSCEV, Bucket.ChainBases[Idx].Offset)
+            : Bucket.BaseSCEV;
+    const SCEVAddRecExpr *BasePtrSCEV = cast<SCEVAddRecExpr>(BaseSCEV);
+    if (!isSafeToExpand(BasePtrSCEV->getStart(), *SE))
+      return MadeChange;
+  }
+
+  BasicBlock *Header = L->getHeader();
+  BasicBlock *LoopPredecessor = L->getLoopPredecessor();
+
+  Type *I64Ty = Type::getInt64Ty(Header->getContext());
+
+  SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "pistart");
+
+  for (unsigned ChainIdx = 0; ChainIdx < Bucket.ChainBases.size(); ++ChainIdx) {
+    unsigned BaseElemIdx = Bucket.ChainSize * ChainIdx;
+    const SCEV *BaseSCEV =
+        ChainIdx ? SE->getAddExpr(Bucket.BaseSCEV,
+                                  Bucket.Elements[BaseElemIdx].Offset)
+                 : Bucket.BaseSCEV;
+    const SCEVAddRecExpr *BasePtrSCEV = cast<SCEVAddRecExpr>(BaseSCEV);
+    assert(BasePtrSCEV->isAffine() &&
+           "Invalid SCEV type for the base ptr for a candidate chain!\n");
+
+    std::pair<Instruction *, Instruction *> Base =
+        rewriteForBase(L, BasePtrSCEV, Bucket.Elements[BaseElemIdx].Instr,
+                       false /* CanPreInc */, UpdateForm, SCEVE, DeletedPtrs);
+
+    if (!Base.first || !Base.second)
+      return MadeChange;
+
+    // Keep track of the replacement pointer values we've inserted so that we
+    // don't generate more pointer values than necessary.
+    SmallPtrSet<Value *, 16> NewPtrs;
+    NewPtrs.insert(Base.first);
+
+    for (unsigned Idx = BaseElemIdx + 1; Idx < BaseElemIdx + Bucket.ChainSize;
+         ++Idx) {
+      BucketElement &I = Bucket.Elements[Idx];
+      Value *Ptr = getPtrOperand(I.Instr);
+      assert(Ptr && "No pointer operand");
+      if (NewPtrs.count(Ptr))
+        continue;
+
+      const SCEV *OffsetSCEV =
+          BaseElemIdx ? SE->getMinusSCEV(Bucket.Elements[Idx].Offset,
+                                         Bucket.Elements[BaseElemIdx].Offset)
+                      : Bucket.Elements[Idx].Offset;
+      Value *OffsetValue = SCEVE.expandCodeFor(
+          OffsetSCEV, I64Ty, LoopPredecessor->getTerminator());
+
+      Instruction *NewPtr = rewriteForBucketElement(Base, Bucket.Elements[Idx],
+                                                    OffsetValue, DeletedPtrs);
+
+      assert(NewPtr && "Wrong rewrite!\n");
+      NewPtrs.insert(NewPtr);
+    }
+  }
+
+  // Clear the rewriter cache, because values that are in the rewriter's cache
+  // can be deleted below, causing the AssertingVH in the cache to trigger.
+  SCEVE.clear();
+
+  for (auto *Ptr : DeletedPtrs) {
+    if (Instruction *IDel = dyn_cast<Instruction>(Ptr))
+      BBChanged.insert(IDel->getParent());
+    RecursivelyDeleteTriviallyDeadInstructions(Ptr);
+  }
+
+  MadeChange = true;
+  return MadeChange;
+}
+
+std::pair<Instruction *, Instruction *>
+PPCLoopInstrFormPrep::rewriteForBase(Loop *L, const SCEVAddRecExpr *BasePtrSCEV,
+                                     Instruction *BaseMemI, bool CanPreInc,
+                                     InstrForm Form, SCEVExpander &SCEVE,
+                                     SmallPtrSet<Value *, 16> &DeletedPtrs) {
+
+  LLVM_DEBUG(dbgs() << "PIP: Transforming: " << *BasePtrSCEV << "\n");
+
+  assert(BasePtrSCEV->getLoop() == L && "AddRec for the wrong loop?");
+
+  Value *BasePtr = getPtrOperand(BaseMemI);
+  assert(BasePtr && "No pointer operand");
+
+  Type *I8Ty = Type::getInt8Ty(BaseMemI->getParent()->getContext());
+  Type *I8PtrTy =
+      Type::getInt8PtrTy(BaseMemI->getParent()->getContext(),
+                         BasePtr->getType()->getPointerAddressSpace());
+
+  bool IsConstantInc = false;
+  const SCEV *BasePtrIncSCEV = BasePtrSCEV->getStepRecurrence(*SE);
+  Value *IncNode = getPreparedIncNode(L, BaseMemI, BasePtrIncSCEV);
+
+  const SCEVConstant *BasePtrIncConstantSCEV =
+      dyn_cast<SCEVConstant>(BasePtrIncSCEV);
+  if (BasePtrIncConstantSCEV)
+    IsConstantInc = true;
+
+  // No valid representation for the increment.
+  if (!IncNode) {
+    LLVM_DEBUG(dbgs() << "Loop Increasement can not be represented!\n");
+    return std::make_pair(nullptr, nullptr);
+  }
+
+  const SCEV *BasePtrStartSCEV = nullptr;
+  if (CanPreInc) {
+    assert(SE->isLoopInvariant(BasePtrIncSCEV, L) &&
+           "Increment is not loop invariant!\n");
+    BasePtrStartSCEV = SE->getMinusSCEV(BasePtrSCEV->getStart(),
+                                        IsConstantInc ? BasePtrIncConstantSCEV
+                                                      : BasePtrIncSCEV);
+  } else
+    BasePtrStartSCEV = BasePtrSCEV->getStart();
+
+  if (alreadyPrepared(L, BaseMemI, BasePtrStartSCEV, BasePtrIncSCEV, Form)) {
+    LLVM_DEBUG(dbgs() << "Instruction form is already prepared!\n");
+    return std::make_pair(nullptr, nullptr);
+  }
+
+  LLVM_DEBUG(dbgs() << "PIP: New start is: " << *BasePtrStartSCEV << "\n");
+
+  BasicBlock *Header = L->getHeader();
+  unsigned HeaderLoopPredCount = pred_size(Header);
+  BasicBlock *LoopPredecessor = L->getLoopPredecessor();
+
+  PHINode *NewPHI = PHINode::Create(I8PtrTy, HeaderLoopPredCount,
+                                    getInstrName(BaseMemI, PHINodeNameSuffix),
+                                    Header->getFirstNonPHI());
+
+  Value *BasePtrStart = SCEVE.expandCodeFor(BasePtrStartSCEV, I8PtrTy,
+                                            LoopPredecessor->getTerminator());
+
+  // Note that LoopPredecessor might occur in the predecessor list multiple
+  // times, and we need to add it the right number of times.
+  for (auto PI : predecessors(Header)) {
+    if (PI != LoopPredecessor)
+      continue;
+
+    NewPHI->addIncoming(BasePtrStart, LoopPredecessor);
+  }
+
+  Instruction *PtrInc = nullptr;
+  Instruction *NewBasePtr = nullptr;
+  if (CanPreInc) {
+    Instruction *InsPoint = &*Header->getFirstInsertionPt();
+    PtrInc = GetElementPtrInst::Create(
+        I8Ty, NewPHI, IncNode, getInstrName(BaseMemI, GEPNodeIncNameSuffix),
+        InsPoint);
+    cast<GetElementPtrInst>(PtrInc)->setIsInBounds(IsPtrInBounds(BasePtr));
+    for (auto PI : predecessors(Header)) {
+      if (PI == LoopPredecessor)
+        continue;
+
+      NewPHI->addIncoming(PtrInc, PI);
+    }
+    if (PtrInc->getType() != BasePtr->getType())
+      NewBasePtr =
+          new BitCastInst(PtrInc, BasePtr->getType(),
+                          getInstrName(PtrInc, CastNodeNameSuffix), InsPoint);
+    else
+      NewBasePtr = PtrInc;
+  } else {
+    // Note that LoopPredecessor might occur in the predecessor list multiple
+    // times, and we need to make sure no more incoming value for them in PHI.
+    for (auto PI : predecessors(Header)) {
+      if (PI == LoopPredecessor)
+        continue;
+
+      // For the latch predecessor, we need to insert a GEP just before the
+      // terminator to increase the address.
+      BasicBlock *BB = PI;
+      Instruction *InsPoint = BB->getTerminator();
+      PtrInc = GetElementPtrInst::Create(
+          I8Ty, NewPHI, IncNode, getInstrName(BaseMemI, GEPNodeIncNameSuffix),
+          InsPoint);
+      cast<GetElementPtrInst>(PtrInc)->setIsInBounds(IsPtrInBounds(BasePtr));
+
+      NewPHI->addIncoming(PtrInc, PI);
+    }
+    PtrInc = NewPHI;
+    if (NewPHI->getType() != BasePtr->getType())
+      NewBasePtr = new BitCastInst(NewPHI, BasePtr->getType(),
+                                   getInstrName(NewPHI, CastNodeNameSuffix),
+                                   &*Header->getFirstInsertionPt());
+    else
+      NewBasePtr = NewPHI;
+  }
+
+  BasePtr->replaceAllUsesWith(NewBasePtr);
+
+  DeletedPtrs.insert(BasePtr);
+
+  return std::make_pair(NewBasePtr, PtrInc);
+}
+
+Instruction *PPCLoopInstrFormPrep::rewriteForBucketElement(
+    std::pair<Instruction *, Instruction *> Base, const BucketElement &Element,
+    Value *OffToBase, SmallPtrSet<Value *, 16> &DeletedPtrs) {
+  Instruction *NewBasePtr = Base.first;
+  Instruction *PtrInc = Base.second;
+  assert((NewBasePtr && PtrInc) && "base does not exist!\n");
+
+  Type *I8Ty = Type::getInt8Ty(PtrInc->getParent()->getContext());
+
+  Value *Ptr = getPtrOperand(Element.Instr);
+  assert(Ptr && "No pointer operand");
+
+  Instruction *RealNewPtr;
+  if (!Element.Offset ||
+      (isa<SCEVConstant>(Element.Offset) &&
+       cast<SCEVConstant>(Element.Offset)->getValue()->isZero())) {
+    RealNewPtr = NewBasePtr;
+  } else {
+    Instruction *PtrIP = dyn_cast<Instruction>(Ptr);
+    if (PtrIP && isa<Instruction>(NewBasePtr) &&
+        cast<Instruction>(NewBasePtr)->getParent() == PtrIP->getParent())
+      PtrIP = nullptr;
+    else if (PtrIP && isa<PHINode>(PtrIP))
+      PtrIP = &*PtrIP->getParent()->getFirstInsertionPt();
+    else if (!PtrIP)
+      PtrIP = Element.Instr;
+
+    assert(OffToBase && "There should be an offset for non base element!\n");
+    GetElementPtrInst *NewPtr = GetElementPtrInst::Create(
+        I8Ty, PtrInc, OffToBase,
+        getInstrName(Element.Instr, GEPNodeOffNameSuffix), PtrIP);
+    if (!PtrIP)
+      NewPtr->insertAfter(cast<Instruction>(PtrInc));
+    NewPtr->setIsInBounds(IsPtrInBounds(Ptr));
+    RealNewPtr = NewPtr;
+  }
+
+  Instruction *ReplNewPtr;
+  if (Ptr->getType() != RealNewPtr->getType()) {
+    ReplNewPtr = new BitCastInst(RealNewPtr, Ptr->getType(),
+                                 getInstrName(Ptr, CastNodeNameSuffix));
+    ReplNewPtr->insertAfter(RealNewPtr);
+  } else
+    ReplNewPtr = RealNewPtr;
+
+  Ptr->replaceAllUsesWith(ReplNewPtr);
+  DeletedPtrs.insert(Ptr);
+
+  return ReplNewPtr;
+}
+
 void PPCLoopInstrFormPrep::addOneCandidate(Instruction *MemI, const SCEV *LSCEV,
                                         SmallVector<Bucket, 16> &Buckets,
                                         unsigned MaxCandidateNum) {
-  assert((MemI && GetPointerOperand(MemI)) &&
+  assert((MemI && getPtrOperand(MemI)) &&
          "Candidate should be a memory instruction.");
   assert(LSCEV && "Invalid SCEV for Ptr value.");
   bool FoundBucket = false;
   for (auto &B : Buckets) {
     const SCEV *Diff = SE->getMinusSCEV(LSCEV, B.BaseSCEV);
     if (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) {
       B.Elements.push_back(BucketElement(CDiff, MemI));
       FoundBucket = true;
       break;
     }
   }
 
   if (!FoundBucket) {
     if (Buckets.size() == MaxCandidateNum)
       return;
     Buckets.push_back(Bucket(LSCEV, MemI));
   }
 }
 
 SmallVector<Bucket, 16> PPCLoopInstrFormPrep::collectCandidates(
     Loop *L,
     std::function<bool(const Instruction *, const Value *, const Type *)>
         isValidCandidate,
     unsigned MaxCandidateNum) {
   SmallVector<Bucket, 16> Buckets;
   for (const auto &BB : L->blocks())
     for (auto &J : *BB) {
-      Value *PtrValue;
-      Type *PointerElementType;
-
-      if (LoadInst *LMemI = dyn_cast<LoadInst>(&J)) {
-        PtrValue = LMemI->getPointerOperand();
-        PointerElementType = LMemI->getType();
-      } else if (StoreInst *SMemI = dyn_cast<StoreInst>(&J)) {
-        PtrValue = SMemI->getPointerOperand();
-        PointerElementType = SMemI->getValueOperand()->getType();
-      } else if (IntrinsicInst *IMemI = dyn_cast<IntrinsicInst>(&J)) {
-        PointerElementType = Type::getInt8Ty(J.getContext());
-        if (IMemI->getIntrinsicID() == Intrinsic::prefetch ||
-            IMemI->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp) {
-          PtrValue = IMemI->getArgOperand(0);
-        } else if (IMemI->getIntrinsicID() == Intrinsic::ppc_vsx_stxvp) {
-          PtrValue = IMemI->getArgOperand(1);
-        } else continue;
-      } else continue;
+      Value *PtrValue = getPtrOperand(&J);
+      if (!PtrValue)
+        continue;
 
       unsigned PtrAddrSpace = PtrValue->getType()->getPointerAddressSpace();
       if (PtrAddrSpace)
         continue;
 
       if (L->isLoopInvariant(PtrValue))
         continue;
 
       const SCEV *LSCEV = SE->getSCEVAtScope(PtrValue, L);
       const SCEVAddRecExpr *LARSCEV = dyn_cast<SCEVAddRecExpr>(LSCEV);
       if (!LARSCEV || LARSCEV->getLoop() != L)
         continue;
 
+      Type *PointerElementType;
+      if (LoadInst *LMemI = dyn_cast<LoadInst>(&J))
+        PointerElementType = LMemI->getType();
+      else if (StoreInst *SMemI = dyn_cast<StoreInst>(&J))
+        PointerElementType = SMemI->getValueOperand()->getType();
+      else {
+        assert(isa<IntrinsicInst>(&J) && "Invalid point operand!\n");
+        PointerElementType = Type::getInt8Ty(J.getContext());
+      }
+
       if (isValidCandidate(&J, PtrValue, PointerElementType))
         addOneCandidate(&J, LSCEV, Buckets, MaxCandidateNum);
     }
   return Buckets;
 }
 
 bool PPCLoopInstrFormPrep::prepareBaseForDispFormChain(Bucket &BucketChain,
                                                     InstrForm Form) {
   // RemainderOffsetInfo details:
   // key:            value of (Offset urem DispConstraint). For DSForm, it can
   //                 be [0, 4).
   // first of pair:  the index of first BucketElement whose remainder is equal
   //                 to key. For key 0, this value must be 0.
   // second of pair: number of load/stores with the same remainder.
   DenseMap<unsigned, std::pair<unsigned, unsigned>> RemainderOffsetInfo;
 
   for (unsigned j = 0, je = BucketChain.Elements.size(); j != je; ++j) {
     if (!BucketChain.Elements[j].Offset)
       RemainderOffsetInfo[0] = std::make_pair(0, 1);
     else {
       unsigned Remainder =
-          BucketChain.Elements[j].Offset->getAPInt().urem(Form);
+          cast<SCEVConstant>(BucketChain.Elements[j].Offset)->getAPInt().urem(Form);
       if (RemainderOffsetInfo.find(Remainder) == RemainderOffsetInfo.end())
         RemainderOffsetInfo[Remainder] = std::make_pair(j, 1);
       else
         RemainderOffsetInfo[Remainder].second++;
     }
   }
   // Currently we choose the most profitable base as the one which has the max
   // number of load/store with same remainder.
for (int j = 0, je = BucketChain.Elements.size(); j != je; ++j) {
 
     // If we'd otherwise pick the first element anyway, there's nothing to do.
     if (j == 0)
       break;
 
     // If our chosen element has no offset from the base pointer, there's
     // nothing to do.
     if (!BucketChain.Elements[j].Offset ||
-        BucketChain.Elements[j].Offset->isZero())
+        cast<SCEVConstant>(BucketChain.Elements[j].Offset)->isZero())
       break;
 
     const SCEV *Offset = BucketChain.Elements[j].Offset;
     BucketChain.BaseSCEV = SE->getAddExpr(BucketChain.BaseSCEV, Offset);
     for (auto &E : BucketChain.Elements) {
       if (E.Offset)
         E.Offset = cast<SCEVConstant>(SE->getMinusSCEV(E.Offset, Offset));
       else
         E.Offset = cast<SCEVConstant>(SE->getNegativeSCEV(Offset));
     }
 
     std::swap(BucketChain.Elements[j], BucketChain.Elements[0]);
     break;
   }
   return true;
 }
 
-bool PPCLoopInstrFormPrep::rewriteLoadStores(Loop *L, Bucket &BucketChain,
-                                          SmallSet<BasicBlock *, 16> &BBChanged,
-                                          InstrForm Form) {
+bool PPCLoopInstrFormPrep::rewriteLoadStores(
+    Loop *L, Bucket &BucketChain, SmallSet<BasicBlock *, 16> &BBChanged,
   bool MadeChange = false;
   const SCEVAddRecExpr *BasePtrSCEV =
       cast<SCEVAddRecExpr>(BucketChain.BaseSCEV);
   if (!BasePtrSCEV->isAffine())
     return MadeChange;
 
-  LLVM_DEBUG(dbgs() << "PIP: Transforming: " << *BasePtrSCEV << "\n");
-
-  assert(BasePtrSCEV->getLoop() == L && "AddRec for the wrong loop?");
-
-  // The instruction corresponding to the Bucket's BaseSCEV must be the first
-  // in the vector of elements.
-  Instruction *MemI = BucketChain.Elements.begin()->Instr;
-  Value *BasePtr = GetPointerOperand(MemI);
-  assert(BasePtr && "No pointer operand");
-
-  Type *I8Ty = Type::getInt8Ty(MemI->getParent()->getContext());
-  Type *I8PtrTy = Type::getInt8PtrTy(MemI->getParent()->getContext(),
-    BasePtr->getType()->getPointerAddressSpace());
-
-  if (!SE->isLoopInvariant(BasePtrSCEV->getStart(), L))
-    return MadeChange;
-
-  bool IsConstantInc = false;
-  const SCEV *BasePtrIncSCEV = BasePtrSCEV->getStepRecurrence(*SE);
-  Value *IncNode = getPreparedIncNode(L, MemI, BasePtrIncSCEV);
-
-  const SCEVConstant *BasePtrIncConstantSCEV =
-      dyn_cast<SCEVConstant>(BasePtrIncSCEV);
-  if (BasePtrIncConstantSCEV)
-    IsConstantInc = true;
-
-  // No valid representation for the increment.
-  if (!IncNode) {
-    LLVM_DEBUG(dbgs() << "Loop Increasement can not be represented!\n");
-    return MadeChange;
-  }
-
-  // For some DS form load/store instructions, it can also be an update form,
-  // if the stride is a multipler of 4. Use update form if prefer it.
-  bool CanPreInc =
-      (Form == UpdateForm ||
-       ((Form == DSForm) && IsConstantInc &&
-        !BasePtrIncConstantSCEV->getAPInt().urem(4) && PreferUpdateForm));
-  const SCEV *BasePtrStartSCEV = nullptr;
-  if (CanPreInc) {
-    assert(SE->isLoopInvariant(BasePtrIncSCEV, L) &&
-           "Increment is not loop invariant!\n");
-    BasePtrStartSCEV = SE->getMinusSCEV(BasePtrSCEV->getStart(),
-                                        IsConstantInc ? BasePtrIncConstantSCEV
-                                                      : BasePtrIncSCEV);
-  } else
-    BasePtrStartSCEV = BasePtrSCEV->getStart();
-
-  if (!isSafeToExpand(BasePtrStartSCEV, *SE))
+  if (!isSafeToExpand(BasePtrSCEV->getStart(), *SE))
     return MadeChange;
 
-  if (alreadyPrepared(L, MemI, BasePtrStartSCEV, BasePtrIncSCEV, Form)) {
-    LLVM_DEBUG(dbgs() << "Instruction form is already prepared!\n");
-    return MadeChange;
-  }
-
-  LLVM_DEBUG(dbgs() << "PIP: New start is: " << *BasePtrStartSCEV << "\n");
+  SmallPtrSet<Value *, 16> DeletedPtrs;
 
   BasicBlock *Header = L->getHeader();
-  unsigned HeaderLoopPredCount = pred_size(Header);
-  BasicBlock *LoopPredecessor = L->getLoopPredecessor();
-
-  PHINode *NewPHI =
-      PHINode::Create(I8PtrTy, HeaderLoopPredCount,
-                      getInstrName(MemI, PHINodeNameSuffix),
-                      Header->getFirstNonPHI());
-
   SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "pistart");
-  Value *BasePtrStart = SCEVE.expandCodeFor(BasePtrStartSCEV, I8PtrTy,
-                                            LoopPredecessor->getTerminator());
-
-  // Note that LoopPredecessor might occur in the predecessor list multiple
-  // times, and we need to add it the right number of times.
-  for (auto PI : predecessors(Header)) {
-    if (PI != LoopPredecessor)
-      continue;
 
-    NewPHI->addIncoming(BasePtrStart, LoopPredecessor);
-  }
+  bool CanPreInc = (Form == UpdateForm ||
+                    ((Form == DSForm) &&
+                     isa<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE)) &&
+                     !cast<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE))
+                          ->getAPInt()
+                          .urem(4) &&
+                     PreferUpdateForm));
+
+  std::pair<Instruction *, Instruction *> Base =
+      rewriteForBase(L, BasePtrSCEV, BucketChain.Elements.begin()->Instr,
+                     CanPreInc, Form, SCEVE, DeletedPtrs);
 
-  Instruction *PtrInc = nullptr;
-  Instruction *NewBasePtr = nullptr;
-  if (CanPreInc) {
-    Instruction *InsPoint = &*Header->getFirstInsertionPt();
-    PtrInc = GetElementPtrInst::Create(I8Ty, NewPHI, IncNode,
-                                       getInstrName(MemI, GEPNodeIncNameSuffix),
-                                       InsPoint);
-    cast<GetElementPtrInst>(PtrInc)->setIsInBounds(IsPtrInBounds(BasePtr));
-    for (auto PI : predecessors(Header)) {
-      if (PI == LoopPredecessor)
-        continue;
-
-      NewPHI->addIncoming(PtrInc, PI);
-    }
-    if (PtrInc->getType() != BasePtr->getType())
-      NewBasePtr = new BitCastInst(
-          PtrInc, BasePtr->getType(),
-          getInstrName(PtrInc, CastNodeNameSuffix), InsPoint);
-    else
-      NewBasePtr = PtrInc;
-  } else {
-    // Note that LoopPredecessor might occur in the predecessor list multiple
-    // times, and we need to make sure no more incoming value for them in PHI.
-    for (auto PI : predecessors(Header)) {
-      if (PI == LoopPredecessor)
-        continue;
-
-      // For the latch predecessor, we need to insert a GEP just before the
-      // terminator to increase the address.
-      BasicBlock *BB = PI;
-      Instruction *InsPoint = BB->getTerminator();
-      PtrInc = GetElementPtrInst::Create(
-          I8Ty, NewPHI, IncNode, getInstrName(MemI, GEPNodeIncNameSuffix),
-          InsPoint);
-      cast<GetElementPtrInst>(PtrInc)->setIsInBounds(IsPtrInBounds(BasePtr));
-
-      NewPHI->addIncoming(PtrInc, PI);
-    }
-    PtrInc = NewPHI;
-    if (NewPHI->getType() != BasePtr->getType())
-      NewBasePtr =
-          new BitCastInst(NewPHI, BasePtr->getType(),
-                          getInstrName(NewPHI, CastNodeNameSuffix),
-                          &*Header->getFirstInsertionPt());
-    else
-      NewBasePtr = NewPHI;
-  }
-
-  // Clear the rewriter cache, because values that are in the rewriter's cache
-  // can be deleted below, causing the AssertingVH in the cache to trigger.
-  SCEVE.clear();
-
-  if (Instruction *IDel = dyn_cast<Instruction>(BasePtr))
-    BBChanged.insert(IDel->getParent());
-  BasePtr->replaceAllUsesWith(NewBasePtr);
-  RecursivelyDeleteTriviallyDeadInstructions(BasePtr);
+  if (!Base.first || !Base.second)
+    return MadeChange;
 
   // Keep track of the replacement pointer values we've inserted so that we
   // don't generate more pointer values than necessary.
   SmallPtrSet<Value *, 16> NewPtrs;
-  NewPtrs.insert(NewBasePtr);
+  NewPtrs.insert(Base.first);
 
   for (auto I = std::next(BucketChain.Elements.begin()),
-       IE = BucketChain.Elements.end(); I != IE; ++I) {
-    Value *Ptr = GetPointerOperand(I->Instr);
+            IE = BucketChain.Elements.end();
+       I != IE; ++I) {
+    Value *Ptr = getPtrOperand(I->Instr);
     assert(Ptr && "No pointer operand");
     if (NewPtrs.count(Ptr))
       continue;
-
-    Instruction *RealNewPtr;
-    if (!I->Offset || I->Offset->getValue()->isZero()) {
-      RealNewPtr = NewBasePtr;
-    } else {
-      Instruction *PtrIP = dyn_cast<Instruction>(Ptr);
-      if (PtrIP && isa<Instruction>(NewBasePtr) &&
-          cast<Instruction>(NewBasePtr)->getParent() == PtrIP->getParent())
-        PtrIP = nullptr;
-      else if (PtrIP && isa<PHINode>(PtrIP))
-        PtrIP = &*PtrIP->getParent()->getFirstInsertionPt();
-      else if (!PtrIP)
-        PtrIP = I->Instr;
-
-      GetElementPtrInst *NewPtr = GetElementPtrInst::Create(
-          I8Ty, PtrInc, I->Offset->getValue(),
-          getInstrName(I->Instr, GEPNodeOffNameSuffix), PtrIP);
-      if (!PtrIP)
-        NewPtr->insertAfter(cast<Instruction>(PtrInc));
-      NewPtr->setIsInBounds(IsPtrInBounds(Ptr));
-      RealNewPtr = NewPtr;
-    }
+    Instruction *NewPtr = rewriteForBucketElement(
+        Base, *I,
+        I->Offset ? cast<SCEVConstant>(I->Offset)->getValue() : nullptr,
+        DeletedPtrs);
+    assert(NewPtr && "wrong rewrite!\n");
+    NewPtrs.insert(NewPtr);
 
+  // Clear the rewriter cache, because values that are in the rewriter's cache
+  // can be deleted below, causing the AssertingVH in the cache to trigger.
+  SCEVE.clear();
+
+  for (auto *Ptr : DeletedPtrs) {
     if (Instruction *IDel = dyn_cast<Instruction>(Ptr))
       BBChanged.insert(IDel->getParent());
-
-    Instruction *ReplNewPtr;
-    if (Ptr->getType() != RealNewPtr->getType()) {
-      ReplNewPtr = new BitCastInst(RealNewPtr, Ptr->getType(),
-        getInstrName(Ptr, CastNodeNameSuffix));
-      ReplNewPtr->insertAfter(RealNewPtr);
-    } else
-      ReplNewPtr = RealNewPtr;
-
-    Ptr->replaceAllUsesWith(ReplNewPtr);
     RecursivelyDeleteTriviallyDeadInstructions(Ptr);
-
-    NewPtrs.insert(RealNewPtr);
   }
 
   MadeChange = true;
 
   SuccPrepCount++;
 
   if (Form == DSForm && !CanPreInc)
     DSFormChainRewritten++;
auto isDQFormCandidate = [&](const Instruction *I, const Value *PtrValue,
     auto *II = dyn_cast<IntrinsicInst>(I);
     if (II)
       return II->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp ||
              II->getIntrinsicID() == Intrinsic::ppc_vsx_stxvp;
     // Check if it is a P9 vector load/store.
     return ST && ST->hasP9Vector() && (PointerElementType->isVectorTy());
   };
 
-  // intrinsic for update form.
+  // Collect buckets of comparable addresses used by loads and stores for update
+  // form.
   SmallVector<Bucket, 16> UpdateFormBuckets =
       collectCandidates(L, isUpdateFormCandidate, MaxVarsUpdateForm);
 
   // Prepare for update form.
   if (!UpdateFormBuckets.empty())
     MadeChange |= updateFormPrep(L, UpdateFormBuckets);
 
   // Collect buckets of comparable addresses used by loads and stores for DS
bool PPCLoopInstrFormPrep::runOnLoop(Loop *L) {
   // form.
   SmallVector<Bucket, 16> DQFormBuckets =
       collectCandidates(L, isDQFormCandidate, MaxVarsDQForm);
 
   // Prepare for DQ form.
   if (!DQFormBuckets.empty())
     MadeChange |= dispFormPrep(L, DQFormBuckets, DQForm);
 
+  // Collect buckets of comparable addresses used by loads and stores for chain
+  // commoning. With chain commoning, we reuses offsets between the chains, so
+  // the register pressure will be reduced.
+  SmallVector<Bucket, 16> Buckets = collectCandidatesForChainCommoning(L);
+
+  // Prepare for chain commoning.
+  if (!Buckets.empty())
+    MadeChange |= chainCommoning(L, Buckets);
+
   return MadeChange;
 }

llvm/test/CodeGen/PowerPC/common-chain.ll

 ; }
 ;
 define i64 @two_chain_same_offset_succ(i8* %p, i64 %offset, i64 %base1, i64 %n) {
 ; CHECK-LABEL: two_chain_same_offset_succ:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    cmpdi r6, 1
 ; CHECK-NEXT:    blt cr0, .LBB0_4
 ; CHECK-NEXT:  # %bb.1: # %for.body.preheader
-; CHECK-NEXT:    sldi r8, r4, 1
+; CHECK-NEXT:    sldi r7, r4, 1
 ; CHECK-NEXT:    mtctr r6
+; CHECK-NEXT:    add r8, r4, r7
+; CHECK-NEXT:    add r7, r5, r4
+; CHECK-NEXT:    add r5, r5, r8
+; CHECK-NEXT:    add r7, r3, r7
 ; CHECK-NEXT:    add r5, r3, r5
 ; CHECK-NEXT:    li r3, 0
-; CHECK-NEXT:    sldi r7, r4, 2
-; CHECK-NEXT:    add r9, r4, r8
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB0_2: # %for.body
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    ldx r6, r5, r4
-; CHECK-NEXT:    ldx r10, r5, r8
-; CHECK-NEXT:    ldx r11, r5, r9
-; CHECK-NEXT:    ldx r12, r5, r7
+; CHECK-NEXT:    ld r6, 0(r7)
+; CHECK-NEXT:    ldx r8, r7, r4
+; CHECK-NEXT:    ld r9, 0(r5)
+; CHECK-NEXT:    ldx r10, r5, r4
+; CHECK-NEXT:    addi r7, r7, 1
 ; CHECK-NEXT:    addi r5, r5, 1
-; CHECK-NEXT:    mulld r6, r10, r6
-; CHECK-NEXT:    mulld r6, r6, r11
-; CHECK-NEXT:    maddld r3, r6, r12, r3
+; CHECK-NEXT:    mulld r6, r8, r6
+; CHECK-NEXT:    mulld r6, r6, r9
+; CHECK-NEXT:    maddld r3, r6, r10, r3
 ; CHECK-NEXT:    bdnz .LBB0_2
 ; CHECK-NEXT:  # %bb.3: # %for.cond.cleanup
 ; CHECK-NEXT:    blr
 ; CHECK-NEXT:  .LBB0_4:
 ; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:    blr
 entry:
   %mul = shl nsw i64 %offset, 1

 
 ; addresses:
 ; 1: base1
 ; 2: + 2*offset
 ; 3: + 2*offset
 ; 4: + 3*offset
 ;
 ; The diff between address 2 and address 1 is offset, and this offset is not reused among other addresses,
-; so we can not common any chains. 
+; so we can not common any chains.
 ;
 ; long long no_reuseable_offset_fail(char *p, long long offset, long long base1, long long n) {
 ;   long long o1 = base1;
 ;   long long o2 = base1 + 2 * offset;
 ;   long long o3 = base1 + 4 * offset;
 ;   long long o4 = base1 + 7 * offset;
 ;   char *p1 = p + o1;
 ;   char *p2 = p + o2;

 ; }
 ;
 define i64 @two_chain_different_offsets_succ(i8* %p, i64 %offset, i64 %base1, i64 %n) {
 ; CHECK-LABEL: two_chain_different_offsets_succ:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    cmpdi r6, 1
 ; CHECK-NEXT:    blt cr0, .LBB5_4
 ; CHECK-NEXT:  # %bb.1: # %for.body.preheader
-; CHECK-NEXT:    mulli r7, r4, 6
-; CHECK-NEXT:    add r5, r3, r5
-; CHECK-NEXT:    sldi r3, r4, 1
-; CHECK-NEXT:    add r9, r4, r3
-; CHECK-NEXT:    mtctr r6
 ; CHECK-NEXT:    sldi r8, r4, 2
+; CHECK-NEXT:    add r7, r5, r4
+; CHECK-NEXT:    mtctr r6
+; CHECK-NEXT:    add r5, r5, r8
+; CHECK-NEXT:    add r7, r3, r7
+; CHECK-NEXT:    sldi r4, r4, 1
+; CHECK-NEXT:    add r5, r3, r5
 ; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB5_2: # %for.body
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    ldx r6, r5, r4
-; CHECK-NEXT:    ldx r10, r5, r9
-; CHECK-NEXT:    ldx r11, r5, r8
-; CHECK-NEXT:    ldx r12, r5, r7
+; CHECK-NEXT:    ld r6, 0(r7)
+; CHECK-NEXT:    ldx r8, r7, r4
+; CHECK-NEXT:    ld r9, 0(r5)
+; CHECK-NEXT:    ldx r10, r5, r4
+; CHECK-NEXT:    addi r7, r7, 1
 ; CHECK-NEXT:    addi r5, r5, 1
-; CHECK-NEXT:    mulld r6, r10, r6
-; CHECK-NEXT:    mulld r6, r6, r11
-; CHECK-NEXT:    maddld r3, r6, r12, r3
+; CHECK-NEXT:    mulld r6, r8, r6
+; CHECK-NEXT:    mulld r6, r6, r9
+; CHECK-NEXT:    maddld r3, r6, r10, r3
 ; CHECK-NEXT:    bdnz .LBB5_2
 ; CHECK-NEXT:  # %bb.3: # %for.cond.cleanup
 ; CHECK-NEXT:    blr
 ; CHECK-NEXT:  .LBB5_4:
 ; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:    blr
 entry:
   %mul = mul nsw i64 %offset, 3

 ; }
 ;
 define i64 @two_chain_two_bases_succ(i8* %p, i64 %offset, i64 %base1, i64 %base2, i64 %n) {
 ; CHECK-LABEL: two_chain_two_bases_succ:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    cmpdi r7, 1
 ; CHECK-NEXT:    blt cr0, .LBB6_4
 ; CHECK-NEXT:  # %bb.1: # %for.body.preheader
-; CHECK-NEXT:    sldi r8, r4, 1
-; CHECK-NEXT:    mtctr r7
-; CHECK-NEXT:    add r9, r4, r8
-; CHECK-NEXT:    add r8, r6, r9
 ; CHECK-NEXT:    add r6, r6, r4
-; CHECK-NEXT:    add r9, r5, r9
 ; CHECK-NEXT:    add r5, r5, r4
-; CHECK-NEXT:    li r4, 0
+; CHECK-NEXT:    mtctr r7
+; CHECK-NEXT:    sldi r4, r4, 1
+; CHECK-NEXT:    add r5, r3, r5
+; CHECK-NEXT:    add r6, r3, r6
+; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB6_2: # %for.body
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    ldx r7, r3, r5
-; CHECK-NEXT:    ldx r10, r3, r9
-; CHECK-NEXT:    ldx r11, r3, r6
-; CHECK-NEXT:    ldx r12, r3, r8
-; CHECK-NEXT:    addi r3, r3, 1
-; CHECK-NEXT:    mulld r7, r10, r7
-; CHECK-NEXT:    mulld r7, r7, r11
-; CHECK-NEXT:    maddld r4, r7, r12, r4
+; CHECK-NEXT:    ld r7, 0(r5)
+; CHECK-NEXT:    ldx r8, r5, r4
+; CHECK-NEXT:    ld r9, 0(r6)
+; CHECK-NEXT:    ldx r10, r6, r4
+; CHECK-NEXT:    addi r5, r5, 1
+; CHECK-NEXT:    addi r6, r6, 1
+; CHECK-NEXT:    mulld r7, r8, r7
+; CHECK-NEXT:    mulld r7, r7, r9
+; CHECK-NEXT:    maddld r3, r7, r10, r3
 ; CHECK-NEXT:    bdnz .LBB6_2
 ; CHECK-NEXT:  # %bb.3: # %for.cond.cleanup
-; CHECK-NEXT:    mr r3, r4
 ; CHECK-NEXT:    blr
 ; CHECK-NEXT:  .LBB6_4:
-; CHECK-NEXT:    li r4, 0
-; CHECK-NEXT:    mr r3, r4
+; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:    blr
 entry:
   %mul = mul nsw i64 %offset, 3
   %cmp44 = icmp sgt i64 %n, 0
   br i1 %cmp44, label %for.body, label %for.cond.cleanup
 
 for.cond.cleanup:                                 ; preds = %for.body, %entry
   %sum.0.lcssa = phi i64 [ 0, %entry ], [ %add15, %for.body ]
for.body:                                         ; preds = %entry, %for.body
   %mul13 = mul i64 %mul12, %5
   %mul14 = mul i64 %mul13, %7
   %add15 = add i64 %mul14, %sum.046
   %inc = add nuw nsw i64 %i.045, 1
   %exitcond.not = icmp eq i64 %inc, %n
   br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
 }
 ;
-; Check chain commoning can reduce register pressure to save register spill/reload. 
+; Check chain commoning can reduce register pressure to save register spill/reload.
 ;
 ; int spill_reduce_succ(double *input1, double *input2, double *output, long long m, long long inc1, long long inc2, long long inc3, long long inc4, long long inc) {
 ;   inc = inc4;
 ; #pragma unroll 4
 ;   for (long long i = 0; i < 4 * m; i++) {
 ;     output[inc + inc1] += input1[inc + inc1] * input2[inc + inc1];
 ;     output[inc + inc2] += input1[inc + inc2] * input2[inc + inc2];
 ;     output[inc + inc3] += input1[inc + inc3] * input2[inc + inc3];
 ;     inc =  inc + inc4;
 ;   }
 ;   return 0;
 ; }
 ;
 define signext i32 @spill_reduce_succ(double* %input1, double* %input2, double* %output, i64 %m, i64 %inc1, i64 %inc2, i64 %inc3, i64 %inc4, i64 %inc) {
 ; CHECK-LABEL: spill_reduce_succ:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    stdu r1, -336(r1)
-; CHECK-NEXT:    .cfi_def_cfa_offset 336
-; CHECK-NEXT:    .cfi_offset r14, -144
-; CHECK-NEXT:    .cfi_offset r15, -136
-; CHECK-NEXT:    .cfi_offset r16, -128
-; CHECK-NEXT:    .cfi_offset r17, -120
-; CHECK-NEXT:    .cfi_offset r18, -112
-; CHECK-NEXT:    .cfi_offset r19, -104
-; CHECK-NEXT:    .cfi_offset r20, -96
-; CHECK-NEXT:    .cfi_offset r21, -88
-; CHECK-NEXT:    .cfi_offset r22, -80
-; CHECK-NEXT:    .cfi_offset r23, -72
-; CHECK-NEXT:    .cfi_offset r24, -64
-; CHECK-NEXT:    .cfi_offset r25, -56
-; CHECK-NEXT:    .cfi_offset r26, -48
-; CHECK-NEXT:    .cfi_offset r27, -40
-; CHECK-NEXT:    .cfi_offset r28, -32
-; CHECK-NEXT:    .cfi_offset r29, -24
-; CHECK-NEXT:    .cfi_offset r30, -16
-; CHECK-NEXT:    .cfi_offset r31, -8
-; CHECK-NEXT:    .cfi_offset r2, -152
 ; CHECK-NEXT:    cmpdi r6, 1
-; CHECK-NEXT:    std r14, 192(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r15, 200(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r16, 208(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r17, 216(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r18, 224(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r19, 232(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r20, 240(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r21, 248(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r22, 256(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r23, 264(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r24, 272(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r25, 280(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r26, 288(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r27, 296(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r28, 304(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r29, 312(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r30, 320(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r31, 328(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r2, 184(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r9, 48(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r8, 56(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r7, 72(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r5, 88(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r4, 80(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r3, 64(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r14, -144(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r15, -136(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r16, -128(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r17, -120(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r18, -112(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r19, -104(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r20, -96(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r21, -88(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r22, -80(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r23, -72(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r24, -64(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r25, -56(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r26, -48(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r27, -40(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r28, -32(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r29, -24(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r30, -16(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r31, -8(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r2, -152(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r8, -168(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    std r7, -160(r1) # 8-byte Folded Spill
 ; CHECK-NEXT:    blt cr0, .LBB7_7
 ; CHECK-NEXT:  # %bb.1: # %for.body.preheader
-; CHECK-NEXT:    sldi r3, r6, 2
-; CHECK-NEXT:    li r4, 1
-; CHECK-NEXT:    mr r18, r10
-; CHECK-NEXT:    cmpdi r3, 1
-; CHECK-NEXT:    iselgt r3, r3, r4
-; CHECK-NEXT:    addi r4, r3, -1
-; CHECK-NEXT:    clrldi r5, r3, 63
-; CHECK-NEXT:    cmpldi r4, 3
-; CHECK-NEXT:    std r5, 40(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    sldi r6, r6, 2
+; CHECK-NEXT:    li r7, 1
+; CHECK-NEXT:    mr r12, r10
+; CHECK-NEXT:    cmpdi r6, 1
+; CHECK-NEXT:    iselgt r6, r6, r7
+; CHECK-NEXT:    addi r7, r6, -1
+; CHECK-NEXT:    clrldi r8, r6, 63
+; CHECK-NEXT:    cmpldi r7, 3
+; CHECK-NEXT:    std r8, -176(r1) # 8-byte Folded Spill
 ; CHECK-NEXT:    blt cr0, .LBB7_4
 ; CHECK-NEXT:  # %bb.2: # %for.body.preheader.new
-; CHECK-NEXT:    ld r0, 48(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    sldi r4, r18, 2
-; CHECK-NEXT:    ld r21, 88(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r22, 80(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r24, 64(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r28, 56(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r19, 72(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r5, r0, r4
-; CHECK-NEXT:    rldicl r3, r3, 62, 2
-; CHECK-NEXT:    rldicl r3, r3, 2, 1
-; CHECK-NEXT:    addi r3, r3, -4
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    rldicl r3, r3, 62, 2
-; CHECK-NEXT:    add r11, r21, r5
-; CHECK-NEXT:    add r6, r22, r5
-; CHECK-NEXT:    add r5, r24, r5
-; CHECK-NEXT:    addi r3, r3, 1
-; CHECK-NEXT:    std r5, 168(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r28, r4
-; CHECK-NEXT:    add r4, r19, r4
-; CHECK-NEXT:    std r6, 176(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    sldi r4, r4, 3
-; CHECK-NEXT:    add r29, r21, r5
-; CHECK-NEXT:    add r6, r22, r5
-; CHECK-NEXT:    add r5, r24, r5
-; CHECK-NEXT:    add r26, r21, r4
-; CHECK-NEXT:    std r5, 152(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r22, r4
-; CHECK-NEXT:    add r4, r24, r4
-; CHECK-NEXT:    std r6, 160(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r4, 136(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r4, r18, 1
-; CHECK-NEXT:    std r5, 144(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r10, r18, r4
-; CHECK-NEXT:    add r5, r0, r10
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r23, r21, r5
-; CHECK-NEXT:    add r6, r22, r5
-; CHECK-NEXT:    add r5, r24, r5
-; CHECK-NEXT:    std r5, 120(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r28, r10
-; CHECK-NEXT:    std r6, 128(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r20, r21, r5
-; CHECK-NEXT:    add r6, r22, r5
-; CHECK-NEXT:    add r5, r24, r5
-; CHECK-NEXT:    std r5, 104(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r19, r10
-; CHECK-NEXT:    std r6, 112(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sub r10, r19, r10
-; CHECK-NEXT:    sldi r5, r5, 3
+; CHECK-NEXT:    sldi r10, r12, 2
+; CHECK-NEXT:    ld r2, -168(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r31, -160(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    rldicl r6, r6, 62, 2
+; CHECK-NEXT:    add r7, r9, r10
+; CHECK-NEXT:    rldicl r6, r6, 2, 1
+; CHECK-NEXT:    sldi r7, r7, 3
+; CHECK-NEXT:    addi r6, r6, -4
+; CHECK-NEXT:    add r8, r5, r7
+; CHECK-NEXT:    add r7, r2, r10
+; CHECK-NEXT:    add r10, r31, r10
+; CHECK-NEXT:    rldicl r6, r6, 62, 2
 ; CHECK-NEXT:    sldi r10, r10, 3
-; CHECK-NEXT:    add r17, r21, r5
-; CHECK-NEXT:    add r6, r22, r5
-; CHECK-NEXT:    add r15, r24, r5
-; CHECK-NEXT:    add r5, r0, r4
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    std r6, 96(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    mtctr r3
-; CHECK-NEXT:    add r14, r21, r5
-; CHECK-NEXT:    add r31, r22, r5
-; CHECK-NEXT:    add r2, r24, r5
-; CHECK-NEXT:    add r5, r28, r4
-; CHECK-NEXT:    add r4, r19, r4
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    sldi r4, r4, 3
-; CHECK-NEXT:    add r6, r21, r5
-; CHECK-NEXT:    add r12, r22, r5
-; CHECK-NEXT:    add r8, r24, r5
-; CHECK-NEXT:    add r9, r21, r4
-; CHECK-NEXT:    add r7, r22, r4
-; CHECK-NEXT:    add r5, r24, r4
-; CHECK-NEXT:    add r4, r18, r0
-; CHECK-NEXT:    sldi r0, r4, 3
-; CHECK-NEXT:    add r4, r21, r0
-; CHECK-NEXT:    add r3, r22, r0
-; CHECK-NEXT:    add r30, r24, r0
-; CHECK-NEXT:    add r0, r18, r28
+; CHECK-NEXT:    addi r6, r6, 1
+; CHECK-NEXT:    sldi r7, r7, 3
+; CHECK-NEXT:    add r30, r5, r10
+; CHECK-NEXT:    add r29, r4, r10
+; CHECK-NEXT:    add r28, r3, r10
+; CHECK-NEXT:    sldi r10, r12, 1
+; CHECK-NEXT:    mtctr r6
+; CHECK-NEXT:    add r7, r5, r7
+; CHECK-NEXT:    li r6, 0
+; CHECK-NEXT:    add r11, r12, r10
+; CHECK-NEXT:    add r0, r9, r11
+; CHECK-NEXT:    sldi r0, r0, 3
+; CHECK-NEXT:    add r27, r5, r0
+; CHECK-NEXT:    add r0, r2, r11
+; CHECK-NEXT:    add r11, r31, r11
+; CHECK-NEXT:    sldi r11, r11, 3
 ; CHECK-NEXT:    sldi r0, r0, 3
-; CHECK-NEXT:    add r27, r22, r0
-; CHECK-NEXT:    add r25, r24, r0
-; CHECK-NEXT:    add r24, r24, r10
-; CHECK-NEXT:    add r22, r22, r10
-; CHECK-NEXT:    add r10, r18, r19
-; CHECK-NEXT:    add r28, r21, r0
-; CHECK-NEXT:    li r0, 0
-; CHECK-NEXT:    sldi r19, r18, 5
+; CHECK-NEXT:    add r25, r5, r11
+; CHECK-NEXT:    add r24, r4, r11
+; CHECK-NEXT:    add r23, r3, r11
+; CHECK-NEXT:    add r11, r9, r10
+; CHECK-NEXT:    add r26, r5, r0
+; CHECK-NEXT:    sldi r11, r11, 3
+; CHECK-NEXT:    add r22, r5, r11
+; CHECK-NEXT:    add r11, r2, r10
+; CHECK-NEXT:    add r10, r31, r10
+; CHECK-NEXT:    sldi r10, r10, 3
+; CHECK-NEXT:    sldi r11, r11, 3
+; CHECK-NEXT:    add r20, r5, r10
+; CHECK-NEXT:    add r19, r4, r10
+; CHECK-NEXT:    add r18, r3, r10
+; CHECK-NEXT:    add r10, r12, r9
+; CHECK-NEXT:    add r21, r5, r11
+; CHECK-NEXT:    sldi r11, r2, 3
+; CHECK-NEXT:    sldi r10, r10, 3
+; CHECK-NEXT:    add r17, r5, r10
+; CHECK-NEXT:    add r10, r12, r2
 ; CHECK-NEXT:    sldi r10, r10, 3
-; CHECK-NEXT:    add r21, r21, r10
-; CHECK-NEXT:    mr r10, r18
+; CHECK-NEXT:    add r16, r5, r10
+; CHECK-NEXT:    add r10, r12, r31
+; CHECK-NEXT:    sldi r31, r31, 3
+; CHECK-NEXT:    sldi r10, r10, 3
+; CHECK-NEXT:    sub r0, r11, r31
+; CHECK-NEXT:    sldi r11, r9, 3
+; CHECK-NEXT:    add r15, r5, r10
+; CHECK-NEXT:    add r14, r3, r10
+; CHECK-NEXT:    sub r31, r11, r31
+; CHECK-NEXT:    add r2, r4, r10
+; CHECK-NEXT:    mr r10, r12
+; CHECK-NEXT:    sldi r11, r12, 5
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB7_3: # %for.body
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    lfdux f0, r22, r19
-; CHECK-NEXT:    lfdux f1, r24, r19
-; CHECK-NEXT:    ld r16, 96(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r10, r10, r18
-; CHECK-NEXT:    add r10, r10, r18
-; CHECK-NEXT:    xsmuldp f0, f1, f0
-; CHECK-NEXT:    lfd f1, 0(r21)
-; CHECK-NEXT:    add r10, r10, r18
-; CHECK-NEXT:    add r10, r10, r18
-; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfd f0, 0(r21)
-; CHECK-NEXT:    add r21, r21, r19
-; CHECK-NEXT:    lfdx f0, r25, r0
-; CHECK-NEXT:    lfdx f1, r27, r0
+; CHECK-NEXT:    lfd f0, 0(r14)
+; CHECK-NEXT:    lfd f1, 0(r2)
+; CHECK-NEXT:    add r10, r10, r12
+; CHECK-NEXT:    add r10, r10, r12
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r28, r0
+; CHECK-NEXT:    lfd f1, 0(r15)
+; CHECK-NEXT:    add r10, r10, r12
+; CHECK-NEXT:    add r10, r10, r12
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r28, r0
-; CHECK-NEXT:    lfdx f0, r30, r0
-; CHECK-NEXT:    lfdx f1, r3, r0
+; CHECK-NEXT:    stfd f0, 0(r15)
+; CHECK-NEXT:    add r15, r15, r11
+; CHECK-NEXT:    lfdx f0, r14, r0
+; CHECK-NEXT:    lfdx f1, r2, r0
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r4, r0
+; CHECK-NEXT:    lfdx f1, r16, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r4, r0
-; CHECK-NEXT:    lfdx f0, r5, r0
-; CHECK-NEXT:    lfdx f1, r7, r0
+; CHECK-NEXT:    stfdx f0, r16, r6
+; CHECK-NEXT:    lfdx f0, r14, r31
+; CHECK-NEXT:    lfdx f1, r2, r31
+; CHECK-NEXT:    add r14, r14, r11
+; CHECK-NEXT:    add r2, r2, r11
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r9, r0
+; CHECK-NEXT:    lfdx f1, r17, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r9, r0
-; CHECK-NEXT:    lfdx f0, r8, r0
-; CHECK-NEXT:    lfdx f1, r12, r0
+; CHECK-NEXT:    stfdx f0, r17, r6
+; CHECK-NEXT:    lfd f0, 0(r18)
+; CHECK-NEXT:    lfd f1, 0(r19)
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r6, r0
+; CHECK-NEXT:    lfdx f1, r20, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r6, r0
-; CHECK-NEXT:    lfdx f0, r2, r0
-; CHECK-NEXT:    lfdx f1, r31, r0
+; CHECK-NEXT:    stfdx f0, r20, r6
+; CHECK-NEXT:    lfdx f0, r18, r0
+; CHECK-NEXT:    lfdx f1, r19, r0
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r14, r0
+; CHECK-NEXT:    lfdx f1, r21, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r14, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    lfdx f1, r16, r0
-; CHECK-NEXT:    ld r16, 104(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r21, r6
+; CHECK-NEXT:    lfdx f0, r18, r31
+; CHECK-NEXT:    lfdx f1, r19, r31
+; CHECK-NEXT:    add r18, r18, r11
+; CHECK-NEXT:    add r19, r19, r11
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r17, r0
+; CHECK-NEXT:    lfdx f1, r22, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r17, r0
-; CHECK-NEXT:    lfdx f0, r16, r0
-; CHECK-NEXT:    ld r16, 112(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r16, r0
-; CHECK-NEXT:    ld r16, 120(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r22, r6
+; CHECK-NEXT:    lfd f0, 0(r23)
+; CHECK-NEXT:    lfd f1, 0(r24)
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r20, r0
+; CHECK-NEXT:    lfdx f1, r25, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r20, r0
-; CHECK-NEXT:    lfdx f0, r16, r0
-; CHECK-NEXT:    ld r16, 128(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r16, r0
-; CHECK-NEXT:    ld r16, 136(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r25, r6
+; CHECK-NEXT:    lfdx f0, r23, r0
+; CHECK-NEXT:    lfdx f1, r24, r0
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r23, r0
+; CHECK-NEXT:    lfdx f1, r26, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r23, r0
-; CHECK-NEXT:    lfdx f0, r16, r0
-; CHECK-NEXT:    ld r16, 144(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r16, r0
-; CHECK-NEXT:    ld r16, 152(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r26, r6
+; CHECK-NEXT:    lfdx f0, r23, r31
+; CHECK-NEXT:    lfdx f1, r24, r31
+; CHECK-NEXT:    add r23, r23, r11
+; CHECK-NEXT:    add r24, r24, r11
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r26, r0
+; CHECK-NEXT:    lfdx f1, r27, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r26, r0
-; CHECK-NEXT:    lfdx f0, r16, r0
-; CHECK-NEXT:    ld r16, 160(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r16, r0
-; CHECK-NEXT:    ld r16, 168(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r27, r6
+; CHECK-NEXT:    lfd f0, 0(r28)
+; CHECK-NEXT:    lfd f1, 0(r29)
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
+; CHECK-NEXT:    lfdx f1, r30, r6
+; CHECK-NEXT:    xsadddp f0, f1, f0
+; CHECK-NEXT:    stfdx f0, r30, r6
+; CHECK-NEXT:    lfdx f0, r28, r0
 ; CHECK-NEXT:    lfdx f1, r29, r0
+; CHECK-NEXT:    xsmuldp f0, f0, f1
+; CHECK-NEXT:    lfdx f1, r7, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r29, r0
-; CHECK-NEXT:    lfdx f0, r16, r0
-; CHECK-NEXT:    ld r16, 176(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r16, r0
+; CHECK-NEXT:    stfdx f0, r7, r6
+; CHECK-NEXT:    lfdx f0, r28, r31
+; CHECK-NEXT:    lfdx f1, r29, r31
+; CHECK-NEXT:    add r28, r28, r11
+; CHECK-NEXT:    add r29, r29, r11
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r11, r0
+; CHECK-NEXT:    lfdx f1, r8, r6
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r11, r0
-; CHECK-NEXT:    add r0, r0, r19
+; CHECK-NEXT:    stfdx f0, r8, r6
+; CHECK-NEXT:    add r6, r6, r11
 ; CHECK-NEXT:    bdnz .LBB7_3
 ; CHECK-NEXT:  .LBB7_4: # %for.cond.cleanup.loopexit.unr-lcssa
-; CHECK-NEXT:    ld r28, 40(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r28, -176(r1) # 8-byte Folded Reload
 ; CHECK-NEXT:    cmpldi r28, 0
 ; CHECK-NEXT:    beq cr0, .LBB7_7
 ; CHECK-NEXT:  # %bb.5: # %for.body.epil.preheader
-; CHECK-NEXT:    ld r11, 72(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r3, 48(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r7, 56(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r0, 88(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    sldi r4, r18, 3
-; CHECK-NEXT:    ld r30, 80(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r29, 64(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r12, r10, r11
-; CHECK-NEXT:    add r3, r10, r3
-; CHECK-NEXT:    add r7, r10, r7
+; CHECK-NEXT:    ld r11, -168(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    add r6, r10, r9
+; CHECK-NEXT:    sldi r7, r12, 3
+; CHECK-NEXT:    sldi r9, r6, 3
+; CHECK-NEXT:    add r11, r10, r11
+; CHECK-NEXT:    add r6, r5, r9
+; CHECK-NEXT:    add r8, r4, r9
+; CHECK-NEXT:    add r9, r3, r9
+; CHECK-NEXT:    sldi r0, r11, 3
+; CHECK-NEXT:    add r11, r5, r0
+; CHECK-NEXT:    add r30, r4, r0
+; CHECK-NEXT:    add r29, r3, r0
+; CHECK-NEXT:    ld r0, -160(r1) # 8-byte Folded Reload
 ; CHECK-NEXT:    mtctr r28
-; CHECK-NEXT:    sub r10, r12, r18
-; CHECK-NEXT:    sldi r6, r3, 3
-; CHECK-NEXT:    sldi r9, r7, 3
+; CHECK-NEXT:    add r10, r10, r0
+; CHECK-NEXT:    sub r12, r10, r12
+; CHECK-NEXT:    sldi r10, r10, 3
 ; CHECK-NEXT:    sldi r12, r12, 3
-; CHECK-NEXT:    sldi r11, r10, 3
-; CHECK-NEXT:    add r3, r0, r6
-; CHECK-NEXT:    add r5, r30, r6
-; CHECK-NEXT:    add r6, r29, r6
-; CHECK-NEXT:    add r7, r0, r9
-; CHECK-NEXT:    add r8, r30, r9
-; CHECK-NEXT:    add r9, r29, r9
-; CHECK-NEXT:    add r12, r0, r12
-; CHECK-NEXT:    li r0, 0
-; CHECK-NEXT:    add r10, r29, r11
-; CHECK-NEXT:    add r11, r30, r11
+; CHECK-NEXT:    add r5, r5, r10
+; CHECK-NEXT:    li r10, 0
+; CHECK-NEXT:    add r3, r3, r12
+; CHECK-NEXT:    add r4, r4, r12
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB7_6: # %for.body.epil
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    lfdux f0, r11, r4
-; CHECK-NEXT:    lfdux f1, r10, r4
+; CHECK-NEXT:    lfdux f0, r4, r7
+; CHECK-NEXT:    lfdux f1, r3, r7
 ; CHECK-NEXT:    xsmuldp f0, f1, f0
-; CHECK-NEXT:    lfd f1, 0(r12)
+; CHECK-NEXT:    lfd f1, 0(r5)
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfd f0, 0(r12)
-; CHECK-NEXT:    add r12, r12, r4
-; CHECK-NEXT:    lfdx f0, r9, r0
-; CHECK-NEXT:    lfdx f1, r8, r0
+; CHECK-NEXT:    stfd f0, 0(r5)
+; CHECK-NEXT:    add r5, r5, r7
+; CHECK-NEXT:    lfdx f0, r29, r10
+; CHECK-NEXT:    lfdx f1, r30, r10
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r7, r0
+; CHECK-NEXT:    lfdx f1, r11, r10
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r7, r0
-; CHECK-NEXT:    lfdx f0, r6, r0
-; CHECK-NEXT:    lfdx f1, r5, r0
+; CHECK-NEXT:    stfdx f0, r11, r10
+; CHECK-NEXT:    lfdx f0, r9, r10
+; CHECK-NEXT:    lfdx f1, r8, r10
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r3, r0
+; CHECK-NEXT:    lfdx f1, r6, r10
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r3, r0
-; CHECK-NEXT:    add r0, r0, r4
+; CHECK-NEXT:    stfdx f0, r6, r10
+; CHECK-NEXT:    add r10, r10, r7
 ; CHECK-NEXT:    bdnz .LBB7_6
 ; CHECK-NEXT:  .LBB7_7: # %for.cond.cleanup
-; CHECK-NEXT:    ld r2, 184(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r31, 328(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r30, 320(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r29, 312(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r2, -152(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r31, -8(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r30, -16(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r29, -24(r1) # 8-byte Folded Reload
 ; CHECK-NEXT:    li r3, 0
-; CHECK-NEXT:    ld r28, 304(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r27, 296(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r26, 288(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r25, 280(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r24, 272(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r23, 264(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r22, 256(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r21, 248(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r20, 240(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r19, 232(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r18, 224(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r17, 216(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r16, 208(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r15, 200(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r14, 192(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    addi r1, r1, 336
+; CHECK-NEXT:    ld r28, -32(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r27, -40(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r26, -48(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r25, -56(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r24, -64(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r23, -72(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r22, -80(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r21, -88(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r20, -96(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r19, -104(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r18, -112(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r17, -120(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r16, -128(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r15, -136(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r14, -144(r1) # 8-byte Folded Reload
 ; CHECK-NEXT:    blr
 entry:
   %cmp49 = icmp sgt i64 %m, 0
   br i1 %cmp49, label %for.body.preheader, label %for.cond.cleanup
 
 for.body.preheader:                               ; preds = %entry
   %0 = shl i64 %m, 2
   %smax52 = call i64 @llvm.smax.i64(i64 %0, i64 1)