[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

128

Better as EnableChainCommoning?

[shchenz]

address @qiucf comments and rebase

[shchenz]

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

128

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?

432

treat it with? treat it as?

507

Why this can not reuse collectCandidates?

513

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

541

TotalCount? ReusableOffsetCount?

542

FirstGroupCount? NewGroupCount?

544

SawSeperator? SawDifferentOffset?

546

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

556

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?

559

// Only one offset?

560

Why sqrt(EleNum)?

579

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

583

Why we need this check here?

620

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?

628

Can we loop through BBChanged only?

645

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

663

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

513

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

556

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

560

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

579

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

583

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.

628

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

645

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?

422

isChainCommoningCandidate , to be aligned with isDSFormCandidate etc.

488

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.

491

This should be checked in collectCandiate, as isValidCandidate.

500

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;


}

513

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?

585

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]);

603

Not all elements?

607

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

858

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

882

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

500

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

513

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

154

Address clang-format warning please.

559

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

830

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

830

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_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);
+//    }
 //===----------------------------------------------------------------------===//
 
 #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> EnableChainCommoning(
+    "ppc-formprep-chain-commoning", cl::init(true), cl::Hidden,
+    cl::desc("Enable 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"));
 
+// Commoning chain will reduce the register pressure, so we don't consider about
+// the PHI nodes number.
+// But commoning chain will increase the addi/add number in the loop and also
+// increase loop ILP. Maximum chain number should be same with hardware
+// IssueWidth, because we won't benefit from ILP if the parallel chains number
+// is bigger than IssueWidth. We assume there are 2 chains in one bucket, so
+// there would be 4 buckets at most on P9(IssueWidth is 8).
+static cl::opt<unsigned> MaxVarsChainCommon("ppc-chaincommon-max-vars",
+                                 cl::Hidden, cl::init(4),
+  cl::desc("Bucket number per loop for PPC loop chain common"));
+
 
 // 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"));
 
+static cl::opt<unsigned> ChainCommonPrepMinThreshold(
+    "ppc-chaincommon-min-threshold", cl::Hidden, cl::init(4),
+    cl::desc("Minimal common base load/store instructions triggering chain "
+             "commoning preparation. Must be not smaller than 4"));
+
 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");
+STATISTIC(ChainCommoningRewritten, "Num of commoning chains");
 
 namespace {
   struct BucketElement {
     BucketElement(const SCEV *O, Instruction *I) : Offset(O), Instr(I) {}
     BucketElement(Instruction *I) : Offset(nullptr), Instr(I) {}
 
     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 *getNodeForInc(Loop *L, Instruction *MemI,
                          const SCEV *BasePtrIncSCEV);
 
+    /// 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 *)>
+        std::function<bool(const Instruction *, Value *, const Type *)>
             isValidCandidate,
+        std::function<bool(const SCEV *)> isValidDiff,
         unsigned MaxCandidateNum);
 
-    /// Add a candidate to candidates \p Buckets.
+    /// Add a candidate to candidates \p Buckets if diff between candidate and
+    /// one base in \p Buckets matches \p isValidDiff.
     void addOneCandidate(Instruction *MemI, const SCEV *LSCEV,
                          SmallVector<Bucket, 16> &Buckets,
+                         std::function<bool(const SCEV *)> isValidDiff,
                          unsigned MaxCandidateNum);
 
     /// Prepare all candidates in \p Buckets for update form.
     bool updateFormPrep(Loop *L, SmallVector<Bucket, 16> &Buckets);
 
     /// Prepare all candidates in \p Buckets for displacement form, now for
     /// ds/dq.
     bool dispFormPrep(Loop *L, SmallVector<Bucket, 16> &Buckets,
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;
 }
 
+// Finding the minimal(chain_number + reusable_offset_number) is a complicated
+// algorithmic problem.
+// For now, the algorithm used here is simply adjusted to handle the case for
+// manually unrolling cases.
+// FIXME: use a more powerful algorithm to find minimal sum of chain_number and
+// reusable_offset_number for one base with multiple offsets.
+bool PPCLoopInstrFormPrep::prepareBasesForCommoningChains(Bucket &CBucket) {
+  // 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'.
+
+  assert(ChainCommonPrepMinThreshold >= 4 &&
+         "Thredhold can not be smaller than 4!\n");
+  if (CBucket.Elements.size() < ChainCommonPrepMinThreshold)
+    return false;
+
+  // We simply select the FirstOffset as the first reusable offset between each
+  // chain element 1 and element 0.
+  const SCEV *FirstOffset = CBucket.Elements[1].Offset;
+
+  // Figure out how many times above FirstOffset is used in the chain.
+  // For a success commoning chain candidate, offset difference between each
+  // chain element 1 and element 0 must be also FirstOffset.
+  unsigned FirstOffsetReusedCount = 1;
+
+  // Figure out how many times above FirstOffset is used in the first chain.
+  // Chain number is FirstOffsetReusedCount / FirstOffsetReusedCountInFirstChain
+  unsigned FirstOffsetReusedCountInFirstChain = 1;
+
+  unsigned EleNum = CBucket.Elements.size();
+  bool SawChainSeparater = false;
+  for (unsigned j = 2; j != EleNum; ++j) {
+    if (SE->getMinusSCEV(CBucket.Elements[j].Offset,
+                         CBucket.Elements[j - 1].Offset) == FirstOffset) {
+      if (!SawChainSeparater)
+        FirstOffsetReusedCountInFirstChain++;
+      FirstOffsetReusedCount++;
+    } else
+      // For now, if we meet any offset which is not FirstOffset, we assume we
+      // find a new Chain.
+      // This makes us miss some opportunities.
+      // For example, we can common:
+      //
+      // {OffsetA, Offset A, OffsetB, OffsetA, OffsetA, OffsetB}
+      //
+      // as two chains:
+      // {{OffsetA, Offset A, OffsetB}, {OffsetA, OffsetA, OffsetB}}
+      // FirstOffsetReusedCount = 4; FirstOffsetReusedCountInFirstChain = 2
+      //
+      // But we fail to common:
+      //
+      // {OffsetA, OffsetB, OffsetA, OffsetA, OffsetB, OffsetA}
+      // FirstOffsetReusedCount = 4; FirstOffsetReusedCountInFirstChain = 1
+
+      SawChainSeparater = true;
+  }
+
+  // FirstOffset is not reused, skip this bucket.
+  if (FirstOffsetReusedCount == 1)
+    return false;
+
+  unsigned ChainNum =
+      FirstOffsetReusedCount / FirstOffsetReusedCountInFirstChain;
+
+  // All elements are increased by FirstOffset.
+  // The number of chains should be sqrt(EleNum).
+  if (!SawChainSeparater)
+    ChainNum = (unsigned)sqrt(EleNum);
+
+  CBucket.ChainSize = (unsigned)(EleNum / ChainNum);
+
+  // If this is not a perfect chain(eg: not 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]);
+
+  LLVM_DEBUG(dbgs() << "Bucket has " << ChainNum << " chains.\n");
+
+  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) {
+    if (prepareBasesForCommoningChains(Bucket))
+      MadeChange |= rewriteLoadStoresForCommoningChains(L, Bucket, BBChanged);
+  }
+
+  if (MadeChange)
+    for (auto *BB : BBChanged)
+      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;
+
+  BasicBlock *Header = L->getHeader();
+  BasicBlock *LoopPredecessor = L->getLoopPredecessor();
+
+  Type *I64Ty = Type::getInt64Ty(Header->getContext());
+
+  SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "loopprepare");
+
+  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);
+
+    // Make sure the base is able to expand.
+    if (!isSafeToExpand(BasePtrSCEV->getStart(), *SE))
+      return MadeChange;
+
+    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 = getPointerOperandAndType(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;
+
+      // Make sure offset is able to expand. Only need to check one time as the
+      // offsets are reused between different chains.
+      if (!BaseElemIdx)
+        if (!isSafeToExpand(OffsetSCEV, *SE))
+          return false;
+
+      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);
+    }
+
+    ++ChainCommoningRewritten;
+  }
+
+  // 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;
+}
+
 // Rewrite the new base according to BasePtrSCEV.
 // bb.loop.preheader:
 //   %newstart = ...
 // bb.loop.body:
 //   %phinode = phi [ %newstart, %bb.loop.preheader ], [ %add, %bb.loop.body ]
 //   ...
 //   %add = getelementptr %phinode, %inc
 //
 // First returned instruciton is %phinode (or a type cast to %phinode), caller
 // needs this value to rewrite other load/stores in the same chain.
 // Second returned instruction is %add, caller needs this value to rewrite other
 // load/stores in the same chain.
 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 = getPointerOperandAndType(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 = getNodeForInc(L, BaseMemI, BasePtrIncSCEV);
 
   const SCEVConstant *BasePtrIncConstantSCEV =
       dyn_cast<SCEVConstant>(BasePtrIncSCEV);
   if (BasePtrIncConstantSCEV)
     IsConstantInc = true;
if (Ptr->getType() != RealNewPtr->getType()) {
     ReplNewPtr = RealNewPtr;
 
   Ptr->replaceAllUsesWith(ReplNewPtr);
   DeletedPtrs.insert(Ptr);
 
   return ReplNewPtr;
 }
 
-void PPCLoopInstrFormPrep::addOneCandidate(Instruction *MemI, const SCEV *LSCEV,
-                                        SmallVector<Bucket, 16> &Buckets,
-                                        unsigned MaxCandidateNum) {
+void PPCLoopInstrFormPrep::addOneCandidate(
+    Instruction *MemI, const SCEV *LSCEV, SmallVector<Bucket, 16> &Buckets,
+    std::function<bool(const SCEV *)> isValidDiff, unsigned MaxCandidateNum) {
   assert((MemI && getPointerOperandAndType(MemI)) &&
          "Candidate should be a memory instruction.");
   assert(LSCEV && "Invalid SCEV for Ptr value.");
+
   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 (const auto *CDiff = dyn_cast<SCEVConstant>(Diff)) {
-      B.Elements.push_back(BucketElement(CDiff, MemI));
+    if (isValidDiff(Diff)) {
+      B.Elements.push_back(BucketElement(Diff, MemI));
       FoundBucket = true;
       break;
     }
   }
 
   if (!FoundBucket) {
-    if (Buckets.size() == MaxCandidateNum)
+    if (Buckets.size() == MaxCandidateNum) {
+      LLVM_DEBUG(dbgs() << "Can not prepare more chains, reach maximum limit "
+                        << MaxCandidateNum << "\n");
       return;
+    }
     Buckets.push_back(Bucket(LSCEV, MemI));
   }
 }
 
 SmallVector<Bucket, 16> PPCLoopInstrFormPrep::collectCandidates(
     Loop *L,
-    std::function<bool(const Instruction *, const Value *, const Type *)>
+    std::function<bool(const Instruction *, Value *, const Type *)>
         isValidCandidate,
-    unsigned MaxCandidateNum) {
+    std::function<bool(const SCEV *)> isValidDiff, unsigned MaxCandidateNum) {
   SmallVector<Bucket, 16> Buckets;
+
   for (const auto &BB : L->blocks())
     for (auto &J : *BB) {
       Value *PtrValue = nullptr;
       Type *PointerElementType = nullptr;
       PtrValue = getPointerOperandAndType(&J, &PointerElementType);
 
       if (!PtrValue)
         continue;
 
       if (PtrValue->getType()->getPointerAddressSpace())
         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;
 
       // Mark that we have candidates for preparing.
       HasCandidateForPrepare = true;
 
       if (isValidCandidate(&J, PtrValue, PointerElementType))
-        addOneCandidate(&J, LSCEV, Buckets, MaxCandidateNum);
+        addOneCandidate(&J, LSCEV, Buckets, isValidDiff, MaxCandidateNum);
     }
   return Buckets;
 }
 
 bool PPCLoopInstrFormPrep::prepareBaseForDispFormChain(Bucket &BucketChain,
                                                     InstrForm Form) {
   // RemainderOffsetInfo details:
   // key:            value of (Offset urem DispConstraint). For DSForm, it can
if (!BasePtrSCEV->isAffine())
     return MadeChange;
 
   if (!isSafeToExpand(BasePtrSCEV->getStart(), *SE))
     return MadeChange;
 
   SmallPtrSet<Value *, 16> DeletedPtrs;
 
   BasicBlock *Header = L->getHeader();
-  SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "pistart");
+  SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "loopprepare");
 
   // For some DS form load/store instructions, it can also be an update form,
   // if the stride is constant and is a multipler of 4. Use update form if
   // prefer it.
   bool CanPreInc = (Form == UpdateForm ||
                     ((Form == DSForm) &&
                      isa<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE)) &&
                      !cast<SCEVConstant>(BasePtrSCEV->getStepRecurrence(*SE))
if (LoopPredecessor)
       MadeChange = true;
   }
   if (!LoopPredecessor) {
     LLVM_DEBUG(dbgs() << "PIP fails since no predecessor for current loop.\n");
     return MadeChange;
   }
   // Check if a load/store has update form. This lambda is used by function
   // collectCandidates which can collect candidates for types defined by lambda.
-  auto isUpdateFormCandidate = [&](const Instruction *I, const Value *PtrValue,
+  auto isUpdateFormCandidate = [&](const Instruction *I, Value *PtrValue,
                                    const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     // There are no update forms for Altivec vector load/stores.
     if (ST && ST->hasAltivec() && PointerElementType->isVectorTy())
       return false;
     // There are no update forms for P10 lxvp/stxvp intrinsic.
     auto *II = dyn_cast<IntrinsicInst>(I);
     if (II && ((II->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp) ||
if (PointerElementType->isIntegerTy(64)) {
         if (ConstInt.isSignedIntN(16) && ConstInt.srem(4) != 0)
           return false;
       }
     }
     return true;
   };
 
   // Check if a load/store has DS form.
-  auto isDSFormCandidate = [](const Instruction *I, const Value *PtrValue,
+  auto isDSFormCandidate = [](const Instruction *I, Value *PtrValue,
                               const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     if (isa<IntrinsicInst>(I))
       return false;
     return (PointerElementType->isIntegerTy(64)) ||
            (PointerElementType->isFloatTy()) ||
            (PointerElementType->isDoubleTy()) ||
            (PointerElementType->isIntegerTy(32) &&
             llvm::any_of(I->users(),
                          [](const User *U) { return isa<SExtInst>(U); }));
   };
 
   // Check if a load/store has DQ form.
-  auto isDQFormCandidate = [&](const Instruction *I, const Value *PtrValue,
+  auto isDQFormCandidate = [&](const Instruction *I, Value *PtrValue,
                                const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     // Check if it is a P10 lxvp/stxvp intrinsic.
     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());
   };
 
+  // Check if a load/store is candidate for chain commoning.
+  // If the SCEV is only with one ptr operand in its start, we can use that
+  // start as a chain separator. Mark this load/store as a candidate.
+  auto isChainCommoningCandidate = [&](const Instruction *I, Value *PtrValue,
+                                       const Type *PointerElementType) {
+    const SCEVAddRecExpr *ARSCEV =
+        cast<SCEVAddRecExpr>(SE->getSCEVAtScope(PtrValue, L));
+    if (!ARSCEV)
+      return false;
+
+    if (!ARSCEV->isAffine())
+      return false;
+
+    const SCEV *Start = ARSCEV->getStart();
+
+    // A single pointer. We can treat it as 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;
+  };
+
+  // Check if the diff is a constant type. This is used for update/DS/DQ form
+  // preparation.
+  auto isValidConstantDiff = [](const SCEV *Diff) {
+    return dyn_cast<SCEVConstant>(Diff) != nullptr;
+  };
+
+  // Make sure the diff between the base and new candidate is required type.
+  // This is used for chain commoning preparation.
+  auto isValidChainCommoningDiff = [](const SCEV *Diff) {
+    assert(Diff && "Invalid Diff!\n");
+
+    // Don't mess up previous dform prepare.
+    if (isa<SCEVConstant>(Diff))
+      return false;
+
+    // A single integer type offset.
+    if (isa<SCEVUnknown>(Diff) && Diff->getType()->isIntegerTy())
+      return true;
+
+    const SCEVNAryExpr *ADiff = dyn_cast<SCEVNAryExpr>(Diff);
+    if (!ADiff)
+      return false;
+
+    for (const SCEV *Op : ADiff->operands())
+      if (!Op->getType()->isIntegerTy())
+        return false;
+
+    return true;
+  };
+
   HasCandidateForPrepare = false;
 
+  LLVM_DEBUG(dbgs() << "Start to prepare for update form.\n");
   // Collect buckets of comparable addresses used by loads and stores for update
   // form.
-  SmallVector<Bucket, 16> UpdateFormBuckets =
-      collectCandidates(L, isUpdateFormCandidate, MaxVarsUpdateForm);
+  SmallVector<Bucket, 16> UpdateFormBuckets = collectCandidates(
+      L, isUpdateFormCandidate, isValidConstantDiff, MaxVarsUpdateForm);
 
   // Prepare for update form.
   if (!UpdateFormBuckets.empty())
     MadeChange |= updateFormPrep(L, UpdateFormBuckets);
-  else if (!HasCandidateForPrepare)
+  else if (!HasCandidateForPrepare) {
+    LLVM_DEBUG(
+        dbgs()
+        << "No prepare candidates found, stop praparation for current loop!\n");
     // If no candidate for preparing, return early.
     return MadeChange;
+  }
 
+  LLVM_DEBUG(dbgs() << "Start to prepare for DS form.\n");
   // Collect buckets of comparable addresses used by loads and stores for DS
   // form.
-  SmallVector<Bucket, 16> DSFormBuckets =
-      collectCandidates(L, isDSFormCandidate, MaxVarsDSForm);
+  SmallVector<Bucket, 16> DSFormBuckets = collectCandidates(
+      L, isDSFormCandidate, isValidConstantDiff, MaxVarsDSForm);
 
   // Prepare for DS form.
   if (!DSFormBuckets.empty())
     MadeChange |= dispFormPrep(L, DSFormBuckets, DSForm);
 
+  LLVM_DEBUG(dbgs() << "Start to prepare for DQ form.\n");
   // Collect buckets of comparable addresses used by loads and stores for DQ
   // form.
-  SmallVector<Bucket, 16> DQFormBuckets =
-      collectCandidates(L, isDQFormCandidate, MaxVarsDQForm);
+  SmallVector<Bucket, 16> DQFormBuckets = collectCandidates(
+      L, isDQFormCandidate, isValidConstantDiff, 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 reuse offsets between the chains, so
+  // the register pressure will be reduced.
+  if (!EnableChainCommoning) {
+    LLVM_DEBUG(dbgs() << "Chain commoning is not enabled.\n");
+    return MadeChange;
+  }
+
+  LLVM_DEBUG(dbgs() << "Start to prepare for chain commoning.\n");
+  SmallVector<Bucket, 16> Buckets =
+      collectCandidates(L, isChainCommoningCandidate, isValidChainCommoningDiff,
+                        MaxVarsChainCommon);
+
+  // 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

 ; }
 ;
 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 ]

 ;     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, 40(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r8, 48(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r7, 64(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r5, 80(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r4, 72(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r3, 56(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 r9, -176(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 r16, r10
-; CHECK-NEXT:    cmpdi r3, 1
-; CHECK-NEXT:    iselgt r3, r3, r4
-; CHECK-NEXT:    addi r4, r3, -1
-; CHECK-NEXT:    clrldi r6, r3, 63
-; CHECK-NEXT:    cmpldi r4, 3
+; CHECK-NEXT:    sldi r6, r6, 2
+; CHECK-NEXT:    li r7, 1
+; CHECK-NEXT:    mr r12, r10
+; CHECK-NEXT:    cmpdi r6, 1
+; CHECK-NEXT:    iselgt r7, r6, r7
+; CHECK-NEXT:    addi r8, r7, -1
+; CHECK-NEXT:    clrldi r6, r7, 63
+; CHECK-NEXT:    cmpldi r8, 3
 ; CHECK-NEXT:    blt cr0, .LBB7_4
 ; CHECK-NEXT:  # %bb.2: # %for.body.preheader.new
-; CHECK-NEXT:    ld r30, 40(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    sldi r4, r16, 2
-; CHECK-NEXT:    ld r19, 80(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r21, 72(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r22, 56(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r27, 48(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r18, 64(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r5, r30, r4
-; CHECK-NEXT:    rldicl r0, r3, 62, 2
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r11, r19, r5
-; CHECK-NEXT:    add r7, r21, r5
-; CHECK-NEXT:    add r5, r22, r5
-; CHECK-NEXT:    std r5, 168(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r27, r4
-; CHECK-NEXT:    add r4, r18, r4
-; CHECK-NEXT:    std r7, 176(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    sldi r4, r4, 3
-; CHECK-NEXT:    add r29, r19, r5
-; CHECK-NEXT:    add r7, r21, r5
-; CHECK-NEXT:    add r5, r22, r5
-; CHECK-NEXT:    add r26, r19, r4
-; CHECK-NEXT:    std r5, 152(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r21, r4
-; CHECK-NEXT:    add r4, r22, r4
-; CHECK-NEXT:    std r7, 160(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    std r4, 136(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r4, r16, 1
-; CHECK-NEXT:    std r5, 144(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r10, r16, r4
-; CHECK-NEXT:    add r3, r18, r4
-; CHECK-NEXT:    add r5, r30, r10
-; CHECK-NEXT:    sldi r3, r3, 3
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r23, r19, r5
-; CHECK-NEXT:    add r7, r21, r5
-; CHECK-NEXT:    add r5, r22, r5
-; CHECK-NEXT:    std r5, 120(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r27, r10
-; CHECK-NEXT:    std r7, 128(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r20, r19, r5
-; CHECK-NEXT:    add r7, r21, r5
-; CHECK-NEXT:    add r5, r22, r5
-; CHECK-NEXT:    std r5, 104(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r18, r10
-; CHECK-NEXT:    std r7, 112(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    sub r10, r18, r10
-; CHECK-NEXT:    sldi r5, r5, 3
+; CHECK-NEXT:    rldicl r7, r7, 62, 2
+; 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:    std r7, -184(r1) # 8-byte Folded Spill
+; CHECK-NEXT:    mr r7, r4
+; CHECK-NEXT:    ld r4, -176(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    add r8, r4, r10
+; CHECK-NEXT:    sldi r8, r8, 3
+; CHECK-NEXT:    add r9, r5, r8
+; CHECK-NEXT:    add r8, r2, r10
+; CHECK-NEXT:    add r10, r31, r10
 ; CHECK-NEXT:    sldi r10, r10, 3
-; CHECK-NEXT:    add r17, r19, r5
-; CHECK-NEXT:    add r7, r21, r5
-; CHECK-NEXT:    add r5, r22, r5
-; CHECK-NEXT:    std r5, 88(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r5, r30, r4
-; CHECK-NEXT:    std r7, 96(r1) # 8-byte Folded Spill
-; CHECK-NEXT:    add r7, r19, r3
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r14, r19, r5
-; CHECK-NEXT:    add r31, r21, r5
-; CHECK-NEXT:    add r2, r22, r5
-; CHECK-NEXT:    add r5, r27, r4
-; CHECK-NEXT:    add r4, r22, r3
-; CHECK-NEXT:    sldi r5, r5, 3
-; CHECK-NEXT:    add r12, r19, r5
-; CHECK-NEXT:    add r8, r21, r5
-; CHECK-NEXT:    add r9, r22, r5
-; CHECK-NEXT:    add r5, r21, r3
-; CHECK-NEXT:    add r3, r16, r30
-; CHECK-NEXT:    rldicl r30, r0, 2, 1
-; CHECK-NEXT:    addi r0, r30, -4
-; CHECK-NEXT:    sldi r28, r3, 3
-; CHECK-NEXT:    rldicl r30, r0, 62, 2
-; CHECK-NEXT:    add r3, r19, r28
-; CHECK-NEXT:    addi r0, r30, 1
-; CHECK-NEXT:    add r30, r21, r28
-; CHECK-NEXT:    add r28, r22, r28
-; CHECK-NEXT:    mtctr r0
-; CHECK-NEXT:    add r0, r16, r27
+; CHECK-NEXT:    sldi r8, r8, 3
+; CHECK-NEXT:    add r30, r5, r10
+; CHECK-NEXT:    add r29, r7, r10
+; CHECK-NEXT:    add r28, r3, r10
+; CHECK-NEXT:    sldi r10, r12, 1
+; CHECK-NEXT:    add r8, r5, r8
+; CHECK-NEXT:    add r11, r12, r10
+; CHECK-NEXT:    add r0, r4, 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 r25, r21, r0
-; CHECK-NEXT:    add r24, r22, r0
-; CHECK-NEXT:    add r22, r22, r10
-; CHECK-NEXT:    add r21, r21, r10
-; CHECK-NEXT:    add r10, r16, r18
-; CHECK-NEXT:    add r27, r19, r0
-; CHECK-NEXT:    li r0, 0
-; CHECK-NEXT:    sldi r18, r16, 5
+; CHECK-NEXT:    add r25, r5, r11
+; CHECK-NEXT:    add r24, r7, r11
+; CHECK-NEXT:    add r23, r3, r11
+; CHECK-NEXT:    add r11, r4, 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, r7, r10
+; CHECK-NEXT:    add r18, r3, r10
+; CHECK-NEXT:    add r10, r12, r4
+; CHECK-NEXT:    add r21, r5, r11
+; CHECK-NEXT:    sldi r11, r2, 3
 ; CHECK-NEXT:    sldi r10, r10, 3
-; CHECK-NEXT:    add r19, r19, r10
-; CHECK-NEXT:    mr r10, r16
+; CHECK-NEXT:    add r17, r5, r10
+; CHECK-NEXT:    add r10, r12, r2
+; CHECK-NEXT:    sldi r10, r10, 3
+; CHECK-NEXT:    add r16, r5, r10
+; CHECK-NEXT:    add r10, r12, r31
+; CHECK-NEXT:    sldi r31, r31, 3
+; CHECK-NEXT:    sub r0, r11, r31
+; CHECK-NEXT:    sldi r11, r4, 3
+; CHECK-NEXT:    mr r4, r7
+; CHECK-NEXT:    ld r7, -184(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    sldi r10, r10, 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:    li r11, 0
+; CHECK-NEXT:    mr r10, r12
+; CHECK-NEXT:    rldicl r7, r7, 2, 1
+; CHECK-NEXT:    addi r7, r7, -4
+; CHECK-NEXT:    rldicl r7, r7, 62, 2
+; CHECK-NEXT:    addi r7, r7, 1
+; CHECK-NEXT:    mtctr r7
+; CHECK-NEXT:    sldi r7, r12, 5
 ; CHECK-NEXT:    .p2align 4
 ; CHECK-NEXT:  .LBB7_3: # %for.body
 ; CHECK-NEXT:    #
-; CHECK-NEXT:    lfdux f0, r21, r18
-; CHECK-NEXT:    lfdux f1, r22, r18
-; CHECK-NEXT:    ld r15, 88(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r10, r10, r16
-; CHECK-NEXT:    add r10, r10, r16
-; CHECK-NEXT:    xsmuldp f0, f1, f0
-; CHECK-NEXT:    lfd f1, 0(r19)
-; CHECK-NEXT:    add r10, r10, r16
-; CHECK-NEXT:    add r10, r10, r16
-; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfd f0, 0(r19)
-; CHECK-NEXT:    add r19, r19, r18
-; CHECK-NEXT:    lfdx f0, r24, r0
-; CHECK-NEXT:    lfdx f1, r25, 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, r27, 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, r27, r0
-; CHECK-NEXT:    lfdx f0, r28, r0
-; CHECK-NEXT:    lfdx f1, r30, r0
+; CHECK-NEXT:    stfd f0, 0(r15)
+; CHECK-NEXT:    add r15, r15, r7
+; CHECK-NEXT:    lfdx f0, r14, r0
+; CHECK-NEXT:    lfdx f1, r2, r0
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r3, r0
+; CHECK-NEXT:    lfdx f1, r16, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r3, r0
-; CHECK-NEXT:    lfdx f0, r4, r0
-; CHECK-NEXT:    lfdx f1, r5, r0
+; CHECK-NEXT:    stfdx f0, r16, r11
+; CHECK-NEXT:    lfdx f0, r14, r31
+; CHECK-NEXT:    lfdx f1, r2, r31
+; CHECK-NEXT:    add r14, r14, r7
+; CHECK-NEXT:    add r2, r2, r7
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r7, r0
+; CHECK-NEXT:    lfdx f1, r17, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r7, r0
-; CHECK-NEXT:    lfdx f0, r9, r0
-; CHECK-NEXT:    lfdx f1, r8, r0
+; CHECK-NEXT:    stfdx f0, r17, r11
+; CHECK-NEXT:    lfd f0, 0(r18)
+; CHECK-NEXT:    lfd f1, 0(r19)
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r12, r0
+; CHECK-NEXT:    lfdx f1, r20, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r12, r0
-; CHECK-NEXT:    lfdx f0, r2, r0
-; CHECK-NEXT:    lfdx f1, r31, r0
+; CHECK-NEXT:    stfdx f0, r20, r11
+; 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, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r14, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 96(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
-; CHECK-NEXT:    ld r15, 104(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r21, r11
+; CHECK-NEXT:    lfdx f0, r18, r31
+; CHECK-NEXT:    lfdx f1, r19, r31
+; CHECK-NEXT:    add r18, r18, r7
+; CHECK-NEXT:    add r19, r19, r7
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r17, r0
+; CHECK-NEXT:    lfdx f1, r22, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r17, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 112(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
-; CHECK-NEXT:    ld r15, 120(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r22, r11
+; 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, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r20, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 128(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
-; CHECK-NEXT:    ld r15, 136(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r25, r11
+; 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, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r23, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 144(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
-; CHECK-NEXT:    ld r15, 152(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r26, r11
+; CHECK-NEXT:    lfdx f0, r23, r31
+; CHECK-NEXT:    lfdx f1, r24, r31
+; CHECK-NEXT:    add r23, r23, r7
+; CHECK-NEXT:    add r24, r24, r7
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r26, r0
+; CHECK-NEXT:    lfdx f1, r27, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r26, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 160(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
-; CHECK-NEXT:    ld r15, 168(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    stfdx f0, r27, r11
+; CHECK-NEXT:    lfd f0, 0(r28)
+; CHECK-NEXT:    lfd f1, 0(r29)
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
+; CHECK-NEXT:    lfdx f1, r30, r11
+; CHECK-NEXT:    xsadddp f0, f1, f0
+; CHECK-NEXT:    stfdx f0, r30, r11
+; CHECK-NEXT:    lfdx f0, r28, r0
 ; CHECK-NEXT:    lfdx f1, r29, r0
+; CHECK-NEXT:    xsmuldp f0, f0, f1
+; CHECK-NEXT:    lfdx f1, r8, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r29, r0
-; CHECK-NEXT:    lfdx f0, r15, r0
-; CHECK-NEXT:    ld r15, 176(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    lfdx f1, r15, r0
+; CHECK-NEXT:    stfdx f0, r8, r11
+; CHECK-NEXT:    lfdx f0, r28, r31
+; CHECK-NEXT:    lfdx f1, r29, r31
+; CHECK-NEXT:    add r28, r28, r7
+; CHECK-NEXT:    add r29, r29, r7
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r11, r0
+; CHECK-NEXT:    lfdx f1, r9, r11
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r11, r0
-; CHECK-NEXT:    add r0, r0, r18
+; CHECK-NEXT:    stfdx f0, r9, r11
+; CHECK-NEXT:    add r11, r11, r7
 ; CHECK-NEXT:    bdnz .LBB7_3
 ; CHECK-NEXT:  .LBB7_4: # %for.cond.cleanup.loopexit.unr-lcssa
 ; CHECK-NEXT:    cmpldi r6, 0
 ; CHECK-NEXT:    beq cr0, .LBB7_7
 ; CHECK-NEXT:  # %bb.5: # %for.body.epil.preheader
-; CHECK-NEXT:    ld r12, 64(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r3, 40(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r8, 48(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r30, 80(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    sldi r4, r16, 3
-; CHECK-NEXT:    ld r29, 72(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    ld r28, 56(r1) # 8-byte Folded Reload
-; CHECK-NEXT:    add r0, r10, r12
-; CHECK-NEXT:    add r3, r10, r3
-; CHECK-NEXT:    add r8, r10, r8
-; CHECK-NEXT:    sub r10, r0, r16
-; CHECK-NEXT:    sldi r7, r3, 3
-; CHECK-NEXT:    sldi r11, r8, 3
+; CHECK-NEXT:    ld r0, -168(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    ld r7, -176(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    sldi r8, r12, 3
+; CHECK-NEXT:    add r0, r10, r0
+; CHECK-NEXT:    add r7, r10, r7
 ; CHECK-NEXT:    sldi r0, r0, 3
-; CHECK-NEXT:    sldi r12, r10, 3
-; CHECK-NEXT:    add r3, r30, r7
-; CHECK-NEXT:    add r5, r29, r7
-; CHECK-NEXT:    add r7, r28, r7
-; CHECK-NEXT:    add r8, r30, r11
-; CHECK-NEXT:    add r9, r29, r11
-; CHECK-NEXT:    add r11, r28, r11
-; CHECK-NEXT:    add r30, r30, r0
-; CHECK-NEXT:    li r0, 0
-; CHECK-NEXT:    add r10, r28, r12
-; CHECK-NEXT:    add r12, r29, r12
+; CHECK-NEXT:    sldi r11, r7, 3
+; CHECK-NEXT:    add r30, r5, r0
+; CHECK-NEXT:    add r29, r4, r0
+; CHECK-NEXT:    add r28, r3, r0
+; CHECK-NEXT:    ld r0, -160(r1) # 8-byte Folded Reload
+; CHECK-NEXT:    add r7, r5, r11
+; CHECK-NEXT:    add r9, r4, r11
+; CHECK-NEXT:    add r11, r3, r11
+; 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:    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, r12, r4
-; CHECK-NEXT:    lfdux f1, r10, r4
+; CHECK-NEXT:    lfdux f0, r4, r8
+; CHECK-NEXT:    lfdux f1, r3, r8
 ; CHECK-NEXT:    addi r6, r6, -1
 ; CHECK-NEXT:    cmpldi r6, 0
 ; CHECK-NEXT:    xsmuldp f0, f1, f0
-; CHECK-NEXT:    lfd f1, 0(r30)
+; CHECK-NEXT:    lfd f1, 0(r5)
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfd f0, 0(r30)
-; CHECK-NEXT:    add r30, r30, r4
-; CHECK-NEXT:    lfdx f0, r11, r0
-; CHECK-NEXT:    lfdx f1, r9, r0
+; CHECK-NEXT:    stfd f0, 0(r5)
+; CHECK-NEXT:    add r5, r5, r8
+; CHECK-NEXT:    lfdx f0, r28, r10
+; CHECK-NEXT:    lfdx f1, r29, r10
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r8, r0
+; CHECK-NEXT:    lfdx f1, r30, r10
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r8, r0
-; CHECK-NEXT:    lfdx f0, r7, r0
-; CHECK-NEXT:    lfdx f1, r5, r0
+; CHECK-NEXT:    stfdx f0, r30, r10
+; CHECK-NEXT:    lfdx f0, r11, r10
+; CHECK-NEXT:    lfdx f1, r9, r10
 ; CHECK-NEXT:    xsmuldp f0, f0, f1
-; CHECK-NEXT:    lfdx f1, r3, r0
+; CHECK-NEXT:    lfdx f1, r7, r10
 ; CHECK-NEXT:    xsadddp f0, f1, f0
-; CHECK-NEXT:    stfdx f0, r3, r0
-; CHECK-NEXT:    add r0, r0, r4
+; CHECK-NEXT:    stfdx f0, r7, r10
+; CHECK-NEXT:    add r10, r10, r8
 ; CHECK-NEXT:    bne cr0, .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)