auto

Author: gottesmm

include/swift/Basic/SmallBitVector.h

@@ -0,0 +1,30 @@
+//===--- SmallBitVector.h -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_SMALLBITVECTOR_H
+#define SWIFT_BASIC_SMALLBITVECTOR_H
+
+#include "llvm/ADT/SmallBitVector.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const SmallBitVector &bv) {
+  for (unsigned i = 0, e = bv.size(); i != e; ++i)
+    os << (bv[i] ? '1' : '0');
+  return os;
+}
+
+} // namespace llvm
+
+#endif

include/swift/SIL/FieldSensitivePrunedLiveness.h

@@ -14,7 +14,11 @@
 #define SWIFT_SIL_FIELDSENSITIVEPRUNTEDLIVENESS_H
 
 #include "swift/AST/TypeExpansionContext.h"
+#include "swift/Basic/Debug.h"
+#include "swift/Basic/FrozenMultiMap.h"
 #include "swift/SIL/PrunedLiveness.h"
+#include "llvm/ADT/SmallBitVector.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 
@@ -234,11 +238,10 @@ struct TypeTreeLeafTypeRange {
   SubElementNumber startEltOffset;
   SubElementNumber endEltOffset;
 
-private:
+public:
   TypeTreeLeafTypeRange(SubElementNumber start, SubElementNumber end)
       : startEltOffset(start), endEltOffset(end) {}
 
-public:
   /// The leaf type range for the entire type tree.
   TypeTreeLeafTypeRange(SILValue rootAddress)
       : startEltOffset(0), endEltOffset(TypeSubElementCount(rootAddress)) {}
@@ -280,6 +283,17 @@ struct TypeTreeLeafTypeRange {
       SILValue rootValue, SILInstruction *insertPt, SmallBitVector &neededElements,
       SmallVectorImpl<SILValue> &resultingProjections);
 
+  static void constructProjectionsForNeededElements(
+      SILValue rootValue, SILInstruction *insertPt,
+      SmallBitVector &neededElements,
+      SmallVectorImpl<std::pair<SILValue, TypeTreeLeafTypeRange>>
+          &resultingProjections);
+
+  static void constructProjectionsForNeededElements(
+      SILValue rootValue, SILInstruction *insertPt, TypeTreeLeafTypeRange span,
+      SmallVectorImpl<std::pair<SILValue, TypeTreeLeafTypeRange>>
+          &resultingProjections);
+
   bool operator==(const TypeTreeLeafTypeRange &other) const {
     return startEltOffset == other.startEltOffset &&
            endEltOffset == other.endEltOffset;
@@ -289,27 +303,32 @@ struct TypeTreeLeafTypeRange {
     return !(*this == other);
   }
 
+  /// Return the type tree leaf type range that is the intersection of \p this
+  /// and \p other.
+  Optional<TypeTreeLeafTypeRange>
+  setIntersection(const TypeTreeLeafTypeRange &other) const {
+    unsigned start = startEltOffset;
+    if (startEltOffset < other.startEltOffset)
+      start = other.startEltOffset;
+    unsigned end = endEltOffset;
+    if (endEltOffset >= other.endEltOffset)
+      end = other.endEltOffset;
+    if (start >= end)
+      return None;
+    return TypeTreeLeafTypeRange(start, end);
+  }
+
   /// Is the given leaf type specified by \p singleLeafElementNumber apart of
   /// our \p range of leaf type values in the our larger type.
   bool contains(SubElementNumber singleLeafElementNumber) const {
     return startEltOffset <= singleLeafElementNumber &&
            singleLeafElementNumber < endEltOffset;
   }
 
-  /// Returns true if either of this overlaps at all with the given range.
+  /// Returns true if \p range is completely within this range.
   bool contains(TypeTreeLeafTypeRange range) const {
-    if (startEltOffset <= range.startEltOffset &&
-        range.startEltOffset < endEltOffset)
-      return true;
-
-    // If our start and end offsets, our extent is only 1 and we know that our
-    // value
-    unsigned rangeLastElt = range.endEltOffset - 1;
-    if (range.startEltOffset == rangeLastElt)
-      return false;
-
-    // Othrwise, see if endEltOffset - 1 is within the range.
-    return startEltOffset <= rangeLastElt && rangeLastElt < endEltOffset;
+    return startEltOffset <= range.startEltOffset &&
+           endEltOffset >= range.endEltOffset;
   }
 
   IntRange<unsigned> getRange() const {
@@ -320,12 +339,21 @@ struct TypeTreeLeafTypeRange {
 
   unsigned size() const { return endEltOffset - startEltOffset; }
 
-  void getPerFieldTypeRange(SILType type, SILFunction *fn, llvm::function_ref<void (SILType, TypeTreeLeafTypeRange)> callback);
+  void getPerFieldTypeRange(
+      SILType type, SILFunction *fn,
+      llvm::function_ref<void(SILType, TypeTreeLeafTypeRange)> callback);
 
   /// Construct per field projections if the projection range has any bits in
   /// common with filterBitVector.
-  void constructFilteredProjections(SILValue value, SILInstruction *insertPt, SmallBitVector &filterBitVector,
-                                    llvm::function_ref<void (SILValue, TypeTreeLeafTypeRange)> callback);
+  void constructFilteredProjections(
+      SILValue value, SILInstruction *insertPt, SmallBitVector &filterBitVector,
+      llvm::function_ref<void(SILValue, TypeTreeLeafTypeRange)> callback);
+
+  void print(llvm::raw_ostream &os) const {
+    os << "TypeTreeLeafTypeRange: (start: " << startEltOffset
+       << ", end: " << endEltOffset << ")";
+  }
+  void dump() const { print(llvm::dbgs()); }
 };
 
 /// This is exactly like pruned liveness except that instead of tracking a
@@ -417,7 +445,8 @@ class FieldSensitivePrunedLiveness {
     return UserBlockRange(getAllUsers(), op);
   }
 
-  void initializeDefBlock(SILBasicBlock *defBB, TypeTreeLeafTypeRange span) {
+  void initializeDefBlock(SILBasicBlock *defBB, TypeTreeLeafTypeRange span)
+      __attribute__((optnone)) {
     liveBlocks.initializeDefBlock(defBB, span.startEltOffset,
                                   span.endEltOffset);
   }
@@ -443,10 +472,7 @@ class FieldSensitivePrunedLiveness {
   /// Return the liveness for this specific sub-element of our root value.
   PrunedLiveBlocks::IsLive getBlockLiveness(SILBasicBlock *bb,
                                             unsigned subElementNumber) const {
-    SmallVector<PrunedLiveBlocks::IsLive, 1> isLive;
-    liveBlocks.getBlockLiveness(bb, subElementNumber, subElementNumber + 1,
-                                isLive);
-    return isLive[0];
+    return liveBlocks.getBlockLiveness(bb, subElementNumber);
   }
 
   void getBlockLiveness(
@@ -456,6 +482,10 @@ class FieldSensitivePrunedLiveness {
                                 foundLiveness);
   }
 
+  void getBlockLiveness(SILBasicBlock *bb, SmallBitVector &liveWithinBits,
+                        SmallBitVector &liveOutBits,
+                        SmallBitVector &deadBits) const;
+
   enum IsInterestingUser { NonUser, NonLifetimeEndingUse, LifetimeEndingUse };
 
   /// Return a result indicating whether the given user was identified as an
@@ -471,6 +501,96 @@ class FieldSensitivePrunedLiveness {
   }
 
   unsigned getNumSubElements() const { return liveBlocks.getNumBitsToTrack(); }
+
+  void print(llvm::raw_ostream &os) const { liveBlocks.print(os); }
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+};
+
+/// Record the last use points and CFG edges that form the boundary of
+/// PrunedLiveness.
+///
+/// Dead defs may occur even when the liveness result has uses for every
+/// definition because those uses may occur in unreachable blocks. A dead def
+/// must either be a SILInstruction or SILArgument. This supports memory
+/// location liveness, so there isn't necessary a defining SILValue.
+///
+/// Each boundary edge is identified by its target block. The source of the edge
+/// is the target block's single predecessor which must have at least one other
+/// non-boundary successor.
+class FieldSensitivePrunedLivenessBoundary {
+  llvm::SmallMapVector<SILInstruction *, SmallBitVector, 8> lastUsers;
+  llvm::SmallMapVector<SILBasicBlock *, SmallBitVector, 8> boundaryEdges;
+  llvm::SmallMapVector<SILNode *, SmallBitVector, 1> deadDefs;
+  unsigned numBits;
+
+public:
+  FieldSensitivePrunedLivenessBoundary(unsigned numBits) : numBits(numBits) {}
+
+  /// Sanity check meant for NDEBUG mode.
+  unsigned getNumLastUsersAndDeadDefs(unsigned bitNo) const {
+#ifdef NDEBUG
+    llvm_unreachable("Only call in asserts build!\n");
+#else
+    unsigned count = 0;
+    for (auto &pair : lastUsers) {
+      count += unsigned(pair.second[bitNo]);
+    }
+    for (auto &pair : deadDefs) {
+      count += unsigned(pair.second[bitNo]);
+    }
+    return count;
+#endif
+  }
+
+  using LastUserRange = iterator_range<decltype(lastUsers)::iterator>;
+  LastUserRange getLastUsers() {
+    return make_range(lastUsers.begin(), lastUsers.end());
+  }
+
+  using BoundaryEdgeRange = iterator_range<decltype(boundaryEdges)::iterator>;
+  BoundaryEdgeRange getBoundaryEdges() {
+    return make_range(boundaryEdges.begin(), boundaryEdges.end());
+  }
+
+  using DeadDefRange = iterator_range<decltype(deadDefs)::iterator>;
+  DeadDefRange getDeadDefs() {
+    return make_range(deadDefs.begin(), deadDefs.end());
+  }
+
+  /// Helper entry point to get the last user that creates the correct size
+  /// small bit vector if we haven't seen this last user yet.
+  SmallBitVector &getLastUserBits(SILInstruction *inst) {
+    auto iter = lastUsers.insert({inst, SmallBitVector()});
+    if (iter.second) {
+      iter.first->second.resize(numBits);
+    }
+    return iter.first->second;
+  }
+
+  SmallBitVector &getBoundaryEdgeBits(SILBasicBlock *block) {
+    auto iter = boundaryEdges.insert({block, SmallBitVector()});
+    if (iter.second) {
+      iter.first->second.resize(numBits);
+    }
+    return iter.first->second;
+  }
+
+  SmallBitVector &getDeadDefsBits(SILNode *def) {
+    auto iter = deadDefs.insert({def, SmallBitVector()});
+    if (iter.second) {
+      iter.first->second.resize(numBits);
+    }
+    return iter.first->second;
+  }
+
+  void clear() {
+    lastUsers.clear();
+    boundaryEdges.clear();
+    deadDefs.clear();
+  }
+
+  void print(llvm::raw_ostream &os) const;
+  void dump() const;
 };
 
 template <typename LivenessWithDefs>
@@ -489,7 +609,18 @@ class FieldSensitivePrunedLiveRange : public FieldSensitivePrunedLiveness {
   /// liveness boundary for bits in \p span.
   ///
   /// NOTE: It is assumed that \p inst is correctly described by span.
-  bool isWithinBoundary(SILInstruction *inst, TypeTreeLeafTypeRange span) const __attribute__((optnone));
+  bool isWithinBoundary(SILInstruction *inst, TypeTreeLeafTypeRange span) const;
+
+  /// Compute the boundary from the blocks discovered during liveness analysis.
+  ///
+  /// Precondition: \p liveness.getDiscoveredBlocks() is a valid list of all
+  /// live blocks with no duplicates.
+  ///
+  /// The computed boundary will completely post-dominate, including dead end
+  /// paths. The client should query DeadEndBlocks to ignore those dead end
+  /// paths.
+  void computeBoundary(FieldSensitivePrunedLivenessBoundary &boundary) const
+      __attribute__((optnone));
 };
 
 /// Single defined liveness.
@@ -549,6 +680,10 @@ class FieldSensitiveSSAPrunedLiveRange
   bool isDefBlock(SILBasicBlock *block, unsigned bit) const {
     return def.first->getParentBlock() == block && def.second->contains(bit);
   }
+
+  void
+  findBoundariesInBlock(SILBasicBlock *block, unsigned bitNo, bool isLiveOut,
+                        FieldSensitivePrunedLivenessBoundary &boundary) const;
 };
 
 /// MultiDefPrunedLiveness is computed incrementally by calling updateForUse.
@@ -594,6 +729,13 @@ class FieldSensitiveMultiDefPrunedLiveRange
     return iter->second.contains(bit);
   }
 
+  bool isDefBlock(SILBasicBlock *block, TypeTreeLeafTypeRange span) const {
+    auto iter = defBlocks.find(block);
+    if (iter == defBlocks.end())
+      return false;
+    return span.setIntersection(iter->second).hasValue();
+  }
+
   bool isDef(SILInstruction *inst, unsigned bit) const {
     auto iter = defs.find(cast<SILNode>(inst));
     if (iter == defs.end())
@@ -607,6 +749,26 @@ class FieldSensitiveMultiDefPrunedLiveRange
       return false;
     return iter->second.contains(bit);
   }
+
+  bool isDef(SILInstruction *inst, TypeTreeLeafTypeRange span) const {
+    auto iter = defs.find(cast<SILNode>(inst));
+    if (iter == defs.end())
+      return false;
+    return span.setIntersection(iter->second).hasValue();
+  }
+
+  bool isDef(SILValue value, TypeTreeLeafTypeRange span) const
+      __attribute__((optnone)) {
+    auto iter = defs.find(cast<SILNode>(value));
+    if (iter == defs.end())
+      return false;
+    return span.setIntersection(iter->second).hasValue();
+  }
+
+  void
+  findBoundariesInBlock(SILBasicBlock *block, unsigned bitNo, bool isLiveOut,
+                        FieldSensitivePrunedLivenessBoundary &boundary) const
+      __attribute__((optnone));
 };
 
 } // namespace swift