SIL: Utilities for calculating and verifying memory lifetimes.

In analogy to the ownership verifier, the MemoryLifetimeVerifier checks the lifetime of memory locations.
It's based on MemoryLocations and MemoryDataflow, which are general utilities for analysing memory locations and calculating the lifetime of locations.

Memory locations are limited to addresses which are guaranteed to be not aliased, like @in/inout parameters or alloc_stack.

Author: eeckstein

include/swift/SIL/MemoryLifetime.h

@@ -0,0 +1,361 @@
+//===--- MemoryLifetime.h ---------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file Contains utilities for calculating and verifying memory lifetime.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_MEMORY_LIFETIME_H
+#define SWIFT_SIL_MEMORY_LIFETIME_H
+
+#include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILFunction.h"
+
+namespace swift {
+
+/// The MemoryLocations utility provides functions to analyze memory locations.
+///
+/// Memory locations are limited to addresses which are guaranteed to
+/// be not aliased, like @in/inout parameters and alloc_stack.
+/// Currently only a certain set of address instructions are supported:
+/// Specifically those instructions which are going to be included when SIL
+/// supports opaque values.
+/// TODO: Support more address instructions, like cast instructions.
+///
+/// The MemoryLocations works well together with MemoryDataflow, which can be
+/// used to calculate global dataflow of location information.
+class MemoryLocations {
+public:
+
+  using Bits = llvm::SmallBitVector;
+
+  /// Represents a not-aliased memory location: either an indirect function
+  /// parameter or an alloc_stack.
+  ///
+  /// Each location has a unique number which is index in the
+  /// MemoryLifetime::locations array and the bit number in the bit sets.
+  ///
+  /// Locations can have sub-locations in case the parent location is a struct
+  /// or tuple with fields/elements. So, each top-level location forms a
+  /// tree-like data structure. Sub-locations are only created lazily, i.e. if
+  /// struct/tuple elements are really accessed with struct/tuple_element_addr.
+  ///
+  /// As most alloc_stack locations only live within a single block, such
+  /// single-block locations are not included in the "regular" data flow
+  /// analysis (to not blow up the bit vectors). They are handled separately
+  /// with a simple single-block data flow analysis, which runs independently
+  /// for each block.
+  struct Location {
+
+    /// The SIL value of the memory location.
+    ///
+    /// For top-level locations this is either a function argument or an
+    /// alloc_stack. For sub-locations it's the struct/tuple_element_addr.
+    /// In case there are multiple struct/tuple_element_addr for a single
+    /// field, this is only one representative instruction out of the set.
+    SILValue representativeValue;
+
+    /// All tracked sub-locations.
+    ///
+    /// If all tracked sub-locations cover the whole memory location, the "self"
+    /// bit is not set. In other words: the "self" bit represents all
+    /// sublocations, which are not explicitly tracked as locations.
+    /// For example:
+    /// \code
+    ///   struct Inner {
+    ///     var a: T
+    ///     var b: T
+    ///   }
+    ///   struct Outer {
+    ///     var x: T
+    ///     var y: Inner
+    ///     var z: T      // not accessed in the analyzed function
+    ///   }
+    /// \endcode
+    ///
+    /// If the analyzed function contains:
+    /// \code
+    ///   %a = alloc_stack $Outer                 // = location 0
+    ///   %ox = struct_element_adr %a, #Outer.x   // = location 1
+    ///   %oy = struct_element_adr %a, #Outer.y   // = location 2
+    ///   %ia = struct_element_adr %oy, #Inner.a  // = location 3
+    ///   %ib = struct_element_adr %oy, #Inner.b  // = location 4
+    /// \endcode
+    ///
+    /// the ``subLocations`` bits are:
+    /// \code
+    ///    location 0 (alloc_stack): [0, 1,   3, 4]
+    ///    location 1 (Outer.x):     [   1        ]
+    ///    location 2 (Outer.y):     [        3, 4]
+    ///    location 3 (Inner.a):     [        3   ]
+    ///    location 4 (Inner.b):     [           4]
+    /// \endcode
+    ///
+    /// Bit 2 is never set because Inner is completly represented by its
+    /// sub-locations 3 and 4. But bit 0 is set in location 0 (the "self" bit),
+    /// because it represents the untracked field ``Outer.z``.
+    Bits subLocations;
+
+    /// The accumulated parent bits, including the "self" bit.
+    ///
+    /// For the example given for ``subLocations``, the ``selfAndParents`` bits
+    /// are:
+    /// \code
+    ///    location 0 (alloc_stack): [0           ]
+    ///    location 1 (Outer.x):     [0, 1        ]
+    ///    location 2 (Outer.y):     [0,   2      ]
+    ///    location 3 (Inner.a):     [0,   2, 3   ]
+    ///    location 4 (Inner.b):     [0,   2,    4]
+    /// \endcode
+    Bits selfAndParents;
+
+    /// The location index of the parent, or -1 if it's a top-level location.
+    ///
+    /// For the example given for ``subLocations``, the ``parentIdx`` indices
+    /// are:
+    /// \code
+    ///    location 0 (alloc_stack): -1
+    ///    location 1 (Outer.x):     0
+    ///    location 2 (Outer.y):     0
+    ///    location 3 (Inner.a):     2
+    ///    location 4 (Inner.b):     2
+    /// \endcode
+    int parentIdx;
+
+    /// Used to decide if a location is completely covered by its sub-locations.
+    ///
+    /// -1 means: not yet initialized.
+    int numFieldsNotCoveredBySubfields = -1;
+
+    Location(SILValue val, unsigned index, int parentIdx = -1);
+  };
+
+private:
+  /// The array of locations.
+  llvm::SmallVector<Location, 64> locations;
+
+  /// Mapping from SIL values (function arguments and alloc_stack) to location
+  /// indices.
+  ///
+  /// In case there are multiple struct/tuple_element_addr for a single
+  /// field, this map contains multiple entries mapping to the same location.
+  llvm::DenseMap<SILValue, unsigned> addr2LocIdx;
+
+  /// Memory locations (e.g. alloc_stack) which live in a single basic block.
+  ///
+  /// Those locations are excluded from the locations to keep the bit sets
+  /// small. They can be handled separately with handleSingleBlockLocations().
+  llvm::SmallVector<SingleValueInstruction *, 16> singleBlockLocations;
+
+public:
+  MemoryLocations() {}
+
+  MemoryLocations(const MemoryLocations &) = delete;
+  MemoryLocations &operator=(const MemoryLocations &) = delete;
+
+  /// Returns the number of collected locations, except single-block locations.
+  unsigned getNumLocations() const { return locations.size(); }
+
+  /// Returns the location index corresponding to a memory address or -1, if
+  /// \p addr is not associated with a location.
+  int getLocationIdx(SILValue addr) const;
+
+  /// Returns the location corresponding to a memory address or null, if
+  /// \p addr is not associated with a location.
+  const Location *getLocation(SILValue addr) const {
+    int locIdx = getLocationIdx(addr);
+    if (locIdx >= 0)
+      return &locations[locIdx];
+    return nullptr;
+  }
+
+  /// Returns the location with a given \p index.
+  const Location *getLocation(unsigned index) const {
+    return &locations[index];
+  }
+
+  /// Sets the location bits os \p addr in \p bits, if \p addr is associated
+  /// with a location.
+  void setBits(Bits &bits, SILValue addr) {
+    if (auto *loc = getLocation(addr))
+      bits |= loc->subLocations;
+  }
+
+  /// Clears the location bits os \p addr in \p bits, if \p addr is associated
+  /// with a location.
+  void clearBits(Bits &bits, SILValue addr) {
+    if (auto *loc = getLocation(addr))
+      bits.reset(loc->subLocations);
+  }
+
+  /// Analyzes all locations in a function.
+  ///
+  /// Single-block locations are not analyzed, but added to singleBlockLocations.
+  void analyzeLocations(SILFunction *function);
+
+  /// Analyze a single top-level location.
+  ///
+  /// If all uses of \p loc are okay, the location and its sub-locations are
+  /// added to the data structures.
+  void analyzeLocation(SILValue loc);
+
+  /// Do a block-local processing for all locations in singleBlockLocations.
+  ///
+  /// First, initializes all locations which are alive in a block and then
+  /// calls \p handlerFunc for the block.
+  void handleSingleBlockLocations(
+                       std::function<void (SILBasicBlock *block)> handlerFunc);
+
+  /// Debug dump the MemoryLifetime internals.
+  void dump() const;
+
+  /// Debug dump a bit set .
+  static void dumpBits(const Bits &bits);
+
+private:
+  /// Clears all datastructures, except singleBlockLocations;
+  void clear();
+
+  // (locationIdx, fieldNr) -> subLocationIdx
+  using SubLocationMap = llvm::DenseMap<std::pair<unsigned, unsigned>, unsigned>;
+
+  /// Helper function called by analyzeLocation to check all uses of the
+  /// location recursively.
+  ///
+  /// The \p subLocationMap is a temporary cache to speed up sub-location lookup.
+  bool analyzeLocationUsesRecursively(SILValue V, unsigned locIdx,
+                                      SmallVectorImpl<SILValue> &collectedVals,
+                                      SubLocationMap &subLocationMap);
+
+  /// Helper function called by analyzeLocation to create a sub-location for
+  /// and address projection and check all of its uses.
+  bool analyzeAddrProjection(
+    SingleValueInstruction *projection, unsigned parentLocIdx,unsigned fieldNr,
+    SmallVectorImpl<SILValue> &collectedVals, SubLocationMap &subLocationMap);
+
+  /// Calculates Location::numFieldsNotCoveredBySubfields
+  void initFieldsCounter(Location &loc);
+
+  /// Only memory locations which store a non-trivial type are considered.
+  bool shouldTrackLocation(SILType type, SILFunction *inFunction) {
+    return !type.isTrivial(*inFunction);
+  }
+};
+
+/// The MemoryDataflow utility calculates global dataflow of memory locations.
+///
+/// The MemoryDataflow works well together with MemoryLocations, which can be
+/// used to analyze locations as input to the dataflow.
+/// TODO: Actuall this utility can be used for any kind of dataflow, not just
+/// for memory locations. Consider renaming it.
+class MemoryDataflow {
+
+public:
+  using Bits = MemoryLocations::Bits;
+
+  /// Basic-block specific information used for dataflow analysis.
+  struct BlockState {
+    /// The backlink to the SILBasicBlock.
+    SILBasicBlock *block;
+
+    /// The bits valid at the entry (i.e. the first instruction) of the block.
+    Bits entrySet;
+
+    /// The bits valid at the exit (i.e. after the terminator) of the block.
+    Bits exitSet;
+
+    /// Generated bits of the block.
+    Bits genSet;
+
+    /// Killed bits of the block.
+    Bits killSet;
+
+    /// True, if this block is reachable from the entry block, i.e. is not an
+    /// unreachable block.
+    ///
+    /// This flag is only computed if entryReachabilityAnalysis is called.
+    bool reachableFromEntry = false;
+
+    /// True, if any function-exit block can be reached from this block, i.e. is
+    /// not a block which eventually ends in an unreachable instruction.
+    ///
+    /// This flag is only computed if exitReachableAnalysis is called.
+    bool exitReachable = false;
+
+    BlockState(SILBasicBlock *block = nullptr) : block(block) { }
+
+    // Utility functions for setting and clearing gen- and kill-bits.
+
+    void genBits(SILValue addr, const MemoryLocations &locs) {
+      if (auto *loc = locs.getLocation(addr)) {
+        killSet.reset(loc->subLocations);
+        genSet |= loc->subLocations;
+      }
+    }
+
+    void killBits(SILValue addr, const MemoryLocations &locs) {
+      if (auto *loc = locs.getLocation(addr)) {
+        genSet.reset(loc->subLocations);
+        killSet |= loc->subLocations;
+      }
+    }
+  };
+
+private:
+  /// All block states.
+  std::vector<BlockState> blockStates;
+
+  /// Getting from SILBasicBlock to BlockState.
+  llvm::DenseMap<SILBasicBlock *, BlockState *> block2State;
+
+public:
+  /// Sets up the BlockState datastructures and associates all basic blocks with
+  /// a state.
+  MemoryDataflow(SILFunction *function, unsigned numLocations);
+
+  MemoryDataflow(const MemoryDataflow &) = delete;
+  MemoryDataflow &operator=(const MemoryDataflow &) = delete;
+
+  using iterator = std::vector<BlockState>::iterator;
+
+  iterator begin() { return blockStates.begin(); }
+  iterator end() { return blockStates.end(); }
+
+  /// Returns the state of a block.
+  BlockState *getState(SILBasicBlock *block) {
+    return block2State[block];
+  }
+
+  /// Calculates the BlockState::reachableFromEntry flags.
+  void entryReachabilityAnalysis();
+
+  /// Calculates the BlockState::exitReachable flags.
+  void exitReachableAnalysis();
+
+  /// Derives the block exit sets from the entry sets by applying the gen and
+  /// kill sets.
+  void solveDataflowForward();
+
+  /// Derives the block entry sets from the exit sets by applying the gen and
+  /// kill sets.
+  void solveDataflowBackward();
+
+  /// Debug dump the MemoryLifetime internals.
+  void dump() const;
+};
+
+/// Verifies the lifetime of memory locations in a function.
+void verifyMemoryLifetime(SILFunction *function);
+
+} // end swift namespace
+
+#endif

include/swift/SIL/SILInstruction.h

@@ -3401,8 +3401,7 @@ class EndBorrowInst
       return bbi->getOperand();
     if (auto *lbi = dyn_cast<LoadBorrowInst>(v))
       return lbi->getOperand();
-    llvm::errs() << "Can not end borrow for value: " << v;
-    llvm_unreachable("standard error assertion");
+    return SILValue();
   }
 
   /// Return the set of guaranteed values that have scopes ended by this

lib/SIL/CMakeLists.txt

@@ -10,6 +10,7 @@ add_swift_host_library(swiftSIL STATIC
   Linker.cpp
   LinearLifetimeChecker.cpp
   LoopInfo.cpp
+  MemoryLifetime.cpp
   Notifications.cpp
   OperandOwnership.cpp
   OptimizationRemark.cpp