Avoid generating address phis in LoopRotate

Author: meg-gupta

lib/SILOptimizer/LoopTransforms/LoopRotate.cpp

@@ -65,49 +65,67 @@ hasLoopInvariantOperands(SILInstruction *inst, SILLoop *loop,
 static bool
 canDuplicateOrMoveToPreheader(SILLoop *loop, SILBasicBlock *preheader,
                               SILBasicBlock *bb,
-                              SmallVectorImpl<SILInstruction *> &moves) {
+                              SmallVectorImpl<SILInstruction *> &moves,
+                              SinkAddressProjections &sinkProj) {
   llvm::DenseSet<SILInstruction *> invariants;
   int cost = 0;
   for (auto &instRef : *bb) {
-    OwnershipForwardingMixin *ofm = nullptr;
     auto *inst = &instRef;
-    if (auto *MI = dyn_cast<MethodInst>(inst)) {
-      if (MI->getMember().isForeign)
-        return false;
-      if (!hasLoopInvariantOperands(inst, loop, invariants))
-        continue;
-      moves.push_back(inst);
-      invariants.insert(inst);
-    } else if (!inst->isTriviallyDuplicatable())
+    if (!inst->isTriviallyDuplicatable()) {
       return false;
+    }
     // It wouldn't make sense to rotate dealloc_stack without also rotating the
     // alloc_stack, which is covered by isTriviallyDuplicatable.
-    else if (isa<DeallocStackInst>(inst))
+    if (isa<DeallocStackInst>(inst)) {
+      return false;
+    }
+    OwnershipForwardingMixin *ofm = nullptr;
+    if ((ofm = OwnershipForwardingMixin::get(inst)) &&
+        ofm->getForwardingOwnershipKind() == OwnershipKind::Guaranteed) {
       return false;
-    else if (isa<FunctionRefInst>(inst)) {
+    }
+    if (isa<FunctionRefInst>(inst)) {
       moves.push_back(inst);
       invariants.insert(inst);
-    } else if (isa<DynamicFunctionRefInst>(inst)) {
+      continue;
+    }
+    if (isa<DynamicFunctionRefInst>(inst)) {
       moves.push_back(inst);
       invariants.insert(inst);
-    } else if (isa<PreviousDynamicFunctionRefInst>(inst)) {
+      continue;
+    }
+    if (isa<PreviousDynamicFunctionRefInst>(inst)) {
       moves.push_back(inst);
       invariants.insert(inst);
-    } else if (isa<IntegerLiteralInst>(inst)) {
+      continue;
+    }
+    if (isa<IntegerLiteralInst>(inst)) {
       moves.push_back(inst);
       invariants.insert(inst);
-    } else if ((ofm = OwnershipForwardingMixin::get(inst)) &&
-               ofm->getForwardingOwnershipKind() == OwnershipKind::Guaranteed) {
-      return false;
-    } else if (!inst->mayHaveSideEffects() && !inst->mayReadFromMemory()
-               && !isa<TermInst>(inst) && !isa<AllocationInst>(inst)
-               && /* not marked mayhavesideffects */
-               hasLoopInvariantOperands(inst, loop, invariants)) {
+      continue;
+    }
+    if (auto *MI = dyn_cast<MethodInst>(inst)) {
+      if (MI->getMember().isForeign)
+        return false;
+      if (!hasLoopInvariantOperands(inst, loop, invariants))
+        continue;
       moves.push_back(inst);
       invariants.insert(inst);
-    } else {
-      cost += (int)instructionInlineCost(instRef);
+      continue;
     }
+    if (!inst->mayHaveSideEffects() && !inst->mayReadFromMemory() &&
+        !isa<TermInst>(inst) &&
+        !isa<AllocationInst>(inst) && /* not marked mayhavesideffects */
+        hasLoopInvariantOperands(inst, loop, invariants)) {
+      moves.push_back(inst);
+      invariants.insert(inst);
+      continue;
+    }
+    if (!sinkProj.analyzeAddressProjections(inst)) {
+      return false;
+    }
+
+    cost += (int)instructionInlineCost(instRef);
   }
 
   return cost < LoopRotateSizeLimit;
@@ -378,8 +396,9 @@ bool swift::rotateLoop(SILLoop *loop, DominanceInfo *domInfo,
 
   // Make sure we can duplicate the header.
   SmallVector<SILInstruction *, 8> moveToPreheader;
-  if (!canDuplicateOrMoveToPreheader(loop, preheader, header,
-                                     moveToPreheader)) {
+  SinkAddressProjections sinkProj;
+  if (!canDuplicateOrMoveToPreheader(loop, preheader, header, moveToPreheader,
+                                     sinkProj)) {
     LLVM_DEBUG(llvm::dbgs()
                << *loop << " instructions in header preventing rotating\n");
     return false;
@@ -425,6 +444,14 @@ bool swift::rotateLoop(SILLoop *loop, DominanceInfo *domInfo,
 
   // The other instructions are just cloned to the preheader.
   TermInst *preheaderBranch = preheader->getTerminator();
+
+  // sink address projections to avoid address phis.
+  for (auto &inst : *header) {
+    bool success = sinkProj.analyzeAddressProjections(&inst);
+    assert(success);
+    sinkProj.cloneProjections();
+  }
+
   for (auto &inst : *header) {
     if (SILInstruction *cloned = inst.clone(preheaderBranch)) {
       mapOperands(cloned, valueMap);
@@ -488,16 +515,10 @@ namespace {
 class LoopRotation : public SILFunctionTransform {
 
   void run() override {
+    SILFunction *f = getFunction();
     SILLoopAnalysis *loopAnalysis = PM->getAnalysis<SILLoopAnalysis>();
-    assert(loopAnalysis);
     DominanceAnalysis *domAnalysis = PM->getAnalysis<DominanceAnalysis>();
-    assert(domAnalysis);
-
-    SILFunction *f = getFunction();
-    assert(f);
-
     SILLoopInfo *loopInfo = loopAnalysis->get(f);
-    assert(loopInfo);
     DominanceInfo *domInfo = domAnalysis->get(f);
 
     if (loopInfo->empty()) {