Add AccessPathVerification pass and run it in the pipeline.

Author: atrick

include/swift/SIL/MemAccessUtils.h

@@ -844,6 +844,8 @@ class AccessPath {
 
   int getOffset() const { return offset; }
 
+  bool hasUnknownOffset() const { return offset == UnknownOffset; }
+
   /// Return true if this path contains \p subPath.
   bool contains(AccessPath subPath) const;
 

include/swift/SILOptimizer/PassManager/Passes.def

@@ -70,6 +70,8 @@ PASS(AccessSummaryDumper, "access-summary-dump",
      "Dump Address Parameter Access Summary")
 PASS(AccessedStorageAnalysisDumper, "accessed-storage-analysis-dump",
      "Dump Accessed Storage Analysis Summaries")
+PASS(AccessPathVerification, "access-path-verification",
+     "Verify Access Paths (and Accessed Storage)")
 PASS(AccessedStorageDumper, "accessed-storage-dump",
      "Dump Accessed Storage Information")
 PASS(AccessMarkerElimination, "access-marker-elim",

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1274,7 +1274,7 @@ void AccessPath::Index::print(raw_ostream &os) const {
     os << '#' << getSubObjectIndex();
   else {
     os << '@';
-    if (getOffset() == AccessPath::UnknownOffset)
+    if (isUnknownOffset())
       os << "Unknown";
     else
       os << getOffset();

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -423,6 +423,11 @@ static void addPerfDebugSerializationPipeline(SILPassPipelinePlan &P) {
 static void addPrepareOptimizationsPipeline(SILPassPipelinePlan &P) {
   P.startPipeline("PrepareOptimizationPasses");
 
+  // Verify AccessedStorage once in OSSA before optimizing.
+#ifndef NDEBUG
+  P.addAccessPathVerification();
+#endif
+
   P.addForEachLoopUnroll();
   P.addMandatoryCombine();
   P.addAccessMarkerElimination();
@@ -670,6 +675,11 @@ static void addLastChanceOptPassPipeline(SILPassPipelinePlan &P) {
   // A loop might have only one dynamic access now, i.e. hoistable
   P.addLICM();
 
+  // Verify AccessedStorage once again after optimizing and lowering OSSA.
+#ifndef NDEBUG
+  P.addAccessPathVerification();
+#endif
+
   // Only has an effect if the -assume-single-thread option is specified.
   P.addAssumeSingleThreaded();
 

lib/SILOptimizer/UtilityPasses/AccessPathVerification.cpp

@@ -0,0 +1,135 @@
+//===--- AccessPathVerification.cpp - verify access paths and storage -----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// Verify AccessPath computation. For the address of every memory operation in
+/// the module, compute the access path, compute all the users of that path,
+/// then verify that all users have the same access path.
+///
+/// This is potentially expensive, so there is a fast mode that limits the
+/// number of uses visited per path.
+///
+/// During full verification, also check that all addresses that share an
+/// AccessPath are covered when computed the use list of that AccessPath. This
+/// is important because optimizations may assume that the use list is
+/// complete.
+///
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "access-path-verification"
+#include "swift/SIL/MemAccessUtils.h"
+#include "swift/SIL/PrettyStackTrace.h"
+#include "swift/SIL/SILFunction.h"
+#include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/SILValue.h"
+#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/Debug.h"
+
+using namespace swift;
+
+namespace {
+
+/// Verify access path and uses of each access.
+class AccessPathVerification : public SILModuleTransform {
+  llvm::DenseMap<Operand *, AccessPath> useToPathMap;
+
+  // Transient uses
+  llvm::SmallVector<Operand *, 64> uses;
+
+public:
+  void verifyAccessPath(Operand *operand) {
+    auto pathAndBase = AccessPathWithBase::compute(operand->get());
+    auto accessPath = pathAndBase.accessPath;
+    if (!accessPath.isValid())
+      return;
+
+    auto iterAndInserted = useToPathMap.try_emplace(operand, accessPath);
+    // If this use was already computed from a previously visited path, make
+    // sure the path we just computed matches.
+    if (!iterAndInserted.second) {
+      auto collectedFromPath = iterAndInserted.first->second;
+      if (collectedFromPath != accessPath) {
+        llvm::errs() << "Address use: " << *operand->getUser()
+                     << "  collected from path\n  ";
+        collectedFromPath.dump();
+        llvm::errs() << "  has different path\n  ";
+        accessPath.dump();
+        operand->getUser()->getFunction()->dump();
+        assert(false && "computed path does not match collected path");
+      }
+      return;
+    }
+    // This is a new path, so map all its uses.
+    assert(uses.empty());
+    pathAndBase.collectUses(uses, /*collectContainingUses*/ false);
+    bool foundOperandUse = false;
+    for (Operand *use : uses) {
+      if (use == operand) {
+        foundOperandUse = true;
+        continue;
+      }
+      // (live) subobject projections within an access will be mapped later as a
+      // separate path.
+      switch (use->getUser()->getKind()) {
+      default:
+        break;
+      case SILInstructionKind::StructElementAddrInst:
+      case SILInstructionKind::TupleElementAddrInst:
+      case SILInstructionKind::IndexAddrInst:
+        continue;
+      }
+      auto iterAndInserted = useToPathMap.try_emplace(use, accessPath);
+      if (!iterAndInserted.second) {
+        llvm::errs() << "Address use: " << *operand->getUser()
+                     << "  with path...\n";
+        pathAndBase.dump();
+        llvm::errs() << "  was not collected for: " << *use->getUser();
+        llvm::errs() << "  with path...\n";
+        auto computedPath = iterAndInserted.first->second;
+        computedPath.dump();
+        use->getUser()->getFunction()->dump();
+        assert(false && "missing collected use");
+      }
+    }
+    if (!foundOperandUse && !accessPath.hasUnknownOffset()) {
+      llvm::errs() << "Address use: " << *operand->getUser()
+                   << "  is not a use of path\n  ";
+      accessPath.dump();
+      assert(false && "not a user of its own computed path ");
+    }
+    uses.clear();
+  }
+
+  void run() override {
+    for (auto &fn : *getModule()) {
+      if (fn.empty())
+        continue;
+
+      PrettyStackTraceSILFunction functionDumper("...", &fn);
+      for (auto &bb : fn) {
+        for (auto &inst : bb) {
+          if (inst.mayReadOrWriteMemory())
+            visitAccessedAddress(&inst, [this](Operand *operand) {
+              return verifyAccessPath(operand);
+            });
+        }
+      }
+      useToPathMap.clear();
+    }
+  }
+};
+
+} // end anonymous namespace
+
+SILTransform *swift::createAccessPathVerification() {
+  return new AccessPathVerification();
+}

lib/SILOptimizer/UtilityPasses/CMakeLists.txt

@@ -1,6 +1,7 @@
 target_sources(swiftSILOptimizer PRIVATE
   AADumper.cpp
   AccessSummaryDumper.cpp
+  AccessPathVerification.cpp
   AccessedStorageAnalysisDumper.cpp
   AccessedStorageDumper.cpp
   BasicCalleePrinter.cpp