Convert TransitiveAddressWalker to use CRTP instead of virtual functions.

Author: gottesmm

include/swift/SIL/AddressWalker.h

@@ -37,15 +37,16 @@ namespace swift {
 /// Validated by the SIL verifier as always being able to visit all addresses
 /// derived from alloc_stack, ref_element_addr, project_box, ref_tail_addr and
 /// all other address roots.
+template <typename Impl>
 class TransitiveAddressWalker {
   /// Whether we could tell if this address use didn't escape, did have a
   /// pointer escape, or unknown if we failed to understand something.
   AddressUseKind result = AddressUseKind::NonEscaping;
 
   unsigned didInvalidate = false;
 
-public:
-  virtual ~TransitiveAddressWalker() {}
+  Impl &asImpl() { return *reinterpret_cast<Impl *>(this); }
+  const Impl &asImpl() const { return *reinterpret_cast<const Impl *>(this); }
 
 protected:
   /// Customization point for visiting uses. Returns true if we should continue
@@ -54,9 +55,11 @@ class TransitiveAddressWalker {
   /// NOTE: Do not call this directly from within
   /// findTransitiveUsesForAddress. Please call callVisitUse. This is intended
   /// just for subclasses to override.
-  virtual bool visitUse(Operand *use) { return true; }
+  bool visitUse(Operand *use) { return true; }
 
-  virtual void onError(Operand *use) {}
+  /// Customization point for visiting operands that we were unable to
+  /// understand. These cause us to return AddressUseKind::Unknown.
+  void onError(Operand *use) {}
 
   void meet(AddressUseKind other) {
     assert(!didInvalidate);
@@ -67,15 +70,17 @@ class TransitiveAddressWalker {
   /// Shim that actually calls visitUse and changes early exit.
   void callVisitUse(Operand *use) {
     assert(!didInvalidate);
-    if (!visitUse(use))
+    if (!asImpl().visitUse(use))
       result = AddressUseKind::Unknown;
   }
 
 public:
   AddressUseKind walk(SILValue address) &&;
 };
 
-inline AddressUseKind TransitiveAddressWalker::walk(SILValue projectedAddress) && {
+template <typename Impl>
+inline AddressUseKind
+TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) && {
   assert(!didInvalidate);
 
   // When we exit, set the result to be invalidated so we can't use this again.
@@ -269,7 +274,7 @@ inline AddressUseKind TransitiveAddressWalker::walk(SILValue projectedAddress) &
 
     // We were unable to recognize this user, so set AddressUseKind to unknown
     // and call onError with the specific user that caused the problem.
-    onError(op);
+    asImpl().onError(op);
     return AddressUseKind::Unknown;
   }
 

include/swift/SIL/OwnershipUtils.h

@@ -736,15 +736,16 @@ inline AddressUseKind findTransitiveUsesForAddress(
   // guaranteed uses to determine if a load_borrow is an escape in OSSA. This
   // is OSSA specific behavior and we should probably create a different API
   // for that. But for now, this lets this APIs users stay the same.
-  struct BasicTransitiveAddressVisitor final : TransitiveAddressWalker {
+  struct BasicTransitiveAddressVisitor
+      : TransitiveAddressWalker<BasicTransitiveAddressVisitor> {
     SmallVectorImpl<Operand *> *foundUses;
     std::function<void(Operand *)> *onErrorFunc;
 
     BasicTransitiveAddressVisitor(SmallVectorImpl<Operand *> *foundUses,
                                   std::function<void(Operand *)> *onErrorFunc)
         : foundUses(foundUses), onErrorFunc(onErrorFunc) {}
 
-    bool visitUse(Operand *use) override {
+    bool visitUse(Operand *use) {
       if (!foundUses)
         return true;
 
@@ -771,7 +772,7 @@ inline AddressUseKind findTransitiveUsesForAddress(
       return true;
     }
 
-    void onError(Operand *use) override {
+    void onError(Operand *use) {
       if (onErrorFunc)
         (*onErrorFunc)(use);
     }

lib/SIL/Verifier/SILVerifier.cpp

@@ -732,9 +732,9 @@ struct ImmutableAddressUseVerifier {
 };
 
 static void checkAddressWalkerCanVisitAllTransitiveUses(SILValue address) {
-  struct Visitor final : TransitiveAddressWalker {
-    bool visitUse(Operand *use) override { return true; }
-    void onError(Operand *use) override {}
+  struct Visitor : TransitiveAddressWalker<Visitor> {
+    bool visitUse(Operand *use) { return true; }
+    void onError(Operand *use) {}
   };
 
   Visitor visitor;

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -826,9 +826,9 @@ static SILValue tryRewriteToPartialApplyStack(
 
     bool origIsUnusedDuringClosureLifetime = true;
 
-    class OrigUnusedDuringClosureLifetimeWalker final
-      : public TransitiveAddressWalker
-    {
+    class OrigUnusedDuringClosureLifetimeWalker
+        : public TransitiveAddressWalker<
+              OrigUnusedDuringClosureLifetimeWalker> {
       SSAPrunedLiveness &closureLiveness;
       bool &origIsUnusedDuringClosureLifetime;
     public:
@@ -837,8 +837,8 @@ static SILValue tryRewriteToPartialApplyStack(
         : closureLiveness(closureLiveness),
           origIsUnusedDuringClosureLifetime(origIsUnusedDuringClosureLifetime)
       {}
-    
-      virtual bool visitUse(Operand *origUse) override {
+
+      bool visitUse(Operand *origUse) {
         LLVM_DEBUG(llvm::dbgs() << "looking at use\n";
                    origUse->getUser()->printInContext(llvm::dbgs());
                    llvm::dbgs() << "\n");
@@ -857,7 +857,7 @@ static SILValue tryRewriteToPartialApplyStack(
         return true;
       }
     };
-    
+
     OrigUnusedDuringClosureLifetimeWalker origUseWalker(closureLiveness,
                                              origIsUnusedDuringClosureLifetime);
     auto walkResult = std::move(origUseWalker).walk(orig);

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1469,14 +1469,14 @@ struct CopiedLoadBorrowEliminationState {
 /// An early transform that we run to convert any load_borrow that are copied
 /// directly or that have any subelement that is copied to a load [copy]. This
 /// lets the rest of the optimization handle these as appropriate.
-struct CopiedLoadBorrowEliminationVisitor final
-    : public TransitiveAddressWalker {
+struct CopiedLoadBorrowEliminationVisitor
+    : public TransitiveAddressWalker<CopiedLoadBorrowEliminationVisitor> {
   CopiedLoadBorrowEliminationState &state;
 
   CopiedLoadBorrowEliminationVisitor(CopiedLoadBorrowEliminationState &state)
       : state(state) {}
 
-  bool visitUse(Operand *op) override {
+  bool visitUse(Operand *op) {
     LLVM_DEBUG(llvm::dbgs() << "CopiedLBElim visiting ";
                llvm::dbgs() << " User: " << *op->getUser());
     auto *lbi = dyn_cast<LoadBorrowInst>(op->getUser());
@@ -1857,7 +1857,7 @@ void PartialReinitChecker::performPartialReinitChecking(
 namespace {
 
 /// Visit all of the uses of value in preparation for running our algorithm.
-struct GatherUsesVisitor final : public TransitiveAddressWalker {
+struct GatherUsesVisitor : public TransitiveAddressWalker<GatherUsesVisitor> {
   MoveOnlyAddressCheckerPImpl &moveChecker;
   UseState &useState;
   MarkMustCheckInst *markedValue;
@@ -1873,7 +1873,7 @@ struct GatherUsesVisitor final : public TransitiveAddressWalker {
       : moveChecker(moveChecker), useState(useState), markedValue(markedValue),
         diagnosticEmitter(diagnosticEmitter) {}
 
-  bool visitUse(Operand *op) override;
+  bool visitUse(Operand *op);
   void reset(MarkMustCheckInst *address) { useState.address = address; }
   void clear() { useState.clear(); }
 

lib/SILOptimizer/Mandatory/MoveOnlyUtils.cpp

@@ -391,8 +391,8 @@ struct SimpleTemporaryAllocStackElimState {
   }
 };
 
-struct SimpleTemporaryAllocStackElimVisitor final
-    : public TransitiveAddressWalker {
+struct SimpleTemporaryAllocStackElimVisitor
+    : public TransitiveAddressWalker<SimpleTemporaryAllocStackElimVisitor> {
   SimpleTemporaryAllocStackElimState &state;
   CopyAddrInst *caiToVisit;
   CopyAddrInst *&nextCAI;
@@ -416,7 +416,7 @@ struct SimpleTemporaryAllocStackElimVisitor final
     return true;
   }
 
-  bool visitUse(Operand *op) override {
+  bool visitUse(Operand *op) {
     LLVM_DEBUG(llvm::dbgs() << "SimpleTemporaryAllocStackElimVisitor visiting: "
                             << *op->getUser());
 
@@ -555,12 +555,13 @@ bool siloptimizer::eliminateTemporaryAllocationsFromLet(
     return false;
 
   StackList<CopyAddrInst *> copiesToVisit(markedInst->getFunction());
-  struct FindCopyAddrWalker final : public TransitiveAddressWalker {
+  struct FindCopyAddrWalker
+      : public TransitiveAddressWalker<FindCopyAddrWalker> {
     StackList<CopyAddrInst *> &copiesToVisit;
     FindCopyAddrWalker(StackList<CopyAddrInst *> &copiesToVisit)
         : TransitiveAddressWalker(), copiesToVisit(copiesToVisit) {}
 
-    bool visitUse(Operand *op) override {
+    bool visitUse(Operand *op) {
       auto *cai = dyn_cast<CopyAddrInst>(op->getUser());
       // We want copy_addr that are not a take of src and are an init of their
       // dest.