Merge pull request swiftlang#33987 from atrick/opt-licm-combined-ldst

Use AccessPath in LICM and split loads for combine load/store hoisting

Author: atrick

include/swift/SIL/LoopInfo.h

@@ -60,6 +60,8 @@ class SILLoop : public llvm::LoopBase<SILBasicBlock, SILLoop> {
     }
   }
 
+  SILFunction *getFunction() const { return getHeader()->getParent(); }
+
 private:
   friend class llvm::LoopInfoBase<SILBasicBlock, SILLoop>;
 

include/swift/SIL/MemAccessUtils.h

@@ -1369,7 +1369,7 @@ class AccessUseDefChainVisitor {
   // Result visitNonAccess(SILValue base);
   // Result visitPhi(SILPhiArgument *phi);
   // Result visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper);
-  // Result visitAccessProjection(SingleValueInstruction *cast,
+  // Result visitAccessProjection(SingleValueInstruction *projectedAddr,
   //                              Operand *sourceOper);
 
   Result visit(SILValue sourceAddr);
@@ -1480,6 +1480,82 @@ Result AccessUseDefChainVisitor<Impl, Result>::visit(SILValue sourceAddr) {
 
 } // end namespace swift
 
+//===----------------------------------------------------------------------===//
+//                          AccessUseDefChainCloner
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+
+/// Clone all projections and casts on the access use-def chain until either the
+/// specified predicate is true or the access base is reached.
+///
+/// This will not clone ref_element_addr or ref_tail_addr because those aren't
+/// part of the access chain.
+template <typename UnaryPredicate>
+class AccessUseDefChainCloner
+    : public AccessUseDefChainVisitor<AccessUseDefChainCloner<UnaryPredicate>,
+                                      SILValue> {
+  UnaryPredicate predicate;
+  SILInstruction *insertionPoint;
+
+public:
+  AccessUseDefChainCloner(UnaryPredicate predicate,
+                          SILInstruction *insertionPoint)
+      : predicate(predicate), insertionPoint(insertionPoint) {}
+
+  // Recursive main entry point
+  SILValue cloneUseDefChain(SILValue addr) {
+    if (!predicate(addr))
+      return addr;
+
+    return this->visit(addr);
+  }
+
+  // Recursively clone an address on the use-def chain.
+  SingleValueInstruction *cloneProjection(SingleValueInstruction *projectedAddr,
+                                          Operand *sourceOper) {
+    SILValue projectedSource = cloneUseDefChain(sourceOper->get());
+    SILInstruction *clone = projectedAddr->clone(insertionPoint);
+    clone->setOperand(sourceOper->getOperandNumber(), projectedSource);
+    return cast<SingleValueInstruction>(clone);
+  }
+
+  // MARK: Visitor implementation
+
+  SILValue visitBase(SILValue base, AccessedStorage::Kind kind) {
+    assert(false && "access base cannot be cloned");
+  }
+
+  SILValue visitNonAccess(SILValue base) {
+    assert(false && "unknown address root cannot be cloned");
+    return SILValue();
+  }
+
+  SILValue visitPhi(SILPhiArgument *phi) {
+    assert(false && "unexpected phi on access path");
+    return SILValue();
+  }
+
+  SILValue visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper) {
+    return cloneProjection(cast, sourceOper);
+  }
+
+  SILValue visitAccessProjection(SingleValueInstruction *projectedAddr,
+                                 Operand *sourceOper) {
+    return cloneProjection(projectedAddr, sourceOper);
+  }
+};
+
+template <typename UnaryPredicate>
+SILValue cloneUseDefChain(SILValue addr, SILInstruction *insertionPoint,
+                          UnaryPredicate shouldFollowUse) {
+  return AccessUseDefChainCloner<UnaryPredicate>(shouldFollowUse,
+                                                 insertionPoint)
+      .cloneUseDefChain(addr);
+}
+
+} // end namespace swift
+
 //===----------------------------------------------------------------------===//
 //                              MARK: Verification
 //===----------------------------------------------------------------------===//

lib/SIL/Utils/MemAccessUtils.cpp

@@ -122,14 +122,13 @@ class AccessPhiVisitor
       phiArg->getIncomingPhiValues(pointerWorklist);
   }
 
-  void visitStorageCast(SingleValueInstruction *projectedAddr,
-                        Operand *sourceOper) {
+  void visitStorageCast(SingleValueInstruction *cast, Operand *sourceOper) {
     // Allow conversions to/from pointers and addresses on disjoint phi paths
     // only if the underlying useDefVisitor allows it.
     if (storageCastTy == IgnoreStorageCast)
       pointerWorklist.push_back(sourceOper->get());
     else
-      visitNonAccess(projectedAddr);
+      visitNonAccess(cast);
   }
 
   void visitAccessProjection(SingleValueInstruction *projectedAddr,
@@ -207,8 +206,7 @@ class FindAccessVisitorImpl : public AccessUseDefChainVisitor<Impl, SILValue> {
     return this->asImpl().visitNonAccess(phiArg);
   }
 
-  SILValue visitStorageCast(SingleValueInstruction *projectedAddr,
-                            Operand *sourceAddr) {
+  SILValue visitStorageCast(SingleValueInstruction *, Operand *sourceAddr) {
     assert(storageCastTy == IgnoreStorageCast);
     return sourceAddr->get();
   }
@@ -303,12 +301,11 @@ class FindAccessBaseVisitor
   }
 
   // Override visitStorageCast to avoid seeing through arbitrary address casts.
-  SILValue visitStorageCast(SingleValueInstruction *projectedAddr,
-                            Operand *sourceAddr) {
+  SILValue visitStorageCast(SingleValueInstruction *cast, Operand *sourceAddr) {
     if (storageCastTy == StopAtStorageCast)
-      return visitNonAccess(projectedAddr);
+      return visitNonAccess(cast);
 
-    return SuperTy::visitStorageCast(projectedAddr, sourceAddr);
+    return SuperTy::visitStorageCast(cast, sourceAddr);
   }
 };