[sil] Refactor FieldSensitivePrunedLiveness along the lines of PrunedLiveness.

To do this I removed isWithinBoundary and friends from
FieldSensitiveAddressPrunedLiveness and moved them and defs into a new class
called FieldSensitiveAddressPrunedLiveRange. The former is now akin to
PrunedLiveness and the later is akin to MultiDefPrunedLiveRange. Since we are
dealing with addresses which are inherently not in SSA, I eliminated the extra
CRTP class that PrunedLiveness used to handle both SSA/MultiDef code.

I also ripped out FieldSensitiveAddressPrunedLivenessBoundary since as I was
experimenting with it, I realized that I fundamentally needed a different API
than what the non field sensitive case supports since I have to handle
TypeTreeSpans.

Author: gottesmm

include/swift/SIL/FieldSensitivePrunedLiveness.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SIL_FIELDSENSITIVEPRUNTEDLIVENESS_H
 #define SWIFT_SIL_FIELDSENSITIVEPRUNTEDLIVENESS_H
 
+#include "swift/AST/TypeExpansionContext.h"
 #include "swift/SIL/PrunedLiveness.h"
 
 namespace swift {
@@ -149,7 +150,10 @@ namespace swift {
 /// the original enum and its payload since that would be a verifier caught
 /// leak.
 struct SubElementNumber {
-  unsigned number;
+  /// Our internal sub element representation number. We force 32 bits so that
+  /// our type tree span is always pointer width. This is convenient for storing
+  /// it in other data structures.
+  uint32_t number;
 
   SubElementNumber(unsigned number) : number(number) {}
 
@@ -168,9 +172,22 @@ struct SubElementNumber {
   /// \returns None if we didn't know how to compute sub-element for this
   /// projection.
   static Optional<SubElementNumber> compute(SILValue projectionFromRoot,
-                                            SILValue root);
+                                            SILValue root) {
+    assert(projectionFromRoot->getType().getCategory() ==
+               root->getType().getCategory() &&
+           "projectionFromRoot and root must both be objects or address.");
+    if (root->getType().isObject())
+      return computeForValue(projectionFromRoot, root);
+    return computeForAddress(projectionFromRoot, root);
+  }
 
   operator unsigned() const { return number; }
+
+private:
+  static Optional<SubElementNumber>
+  computeForAddress(SILValue projectionFromRoot, SILValue rootAddress);
+  static Optional<SubElementNumber> computeForValue(SILValue projectionFromRoot,
+                                                    SILValue rootValue);
 };
 
 /// Given a type T, this is the number of leaf field types in T's type tree. A
@@ -196,16 +213,24 @@ struct TypeSubElementCount {
   TypeSubElementCount(SILType type, SILModule &mod,
                       TypeExpansionContext context);
 
+  /// Helper method that invokes the SILModule &mod entry point.
+  TypeSubElementCount(SILType type, SILFunction *fn)
+      : TypeSubElementCount(type, fn->getModule(),
+                            TypeExpansionContext(*fn)) {}
+
   TypeSubElementCount(SILValue value)
       : TypeSubElementCount(value->getType(), *value->getModule(),
                             TypeExpansionContext(*value->getFunction())) {}
 
   operator unsigned() const { return number; }
 };
 
+class FieldSensitivePrunedLiveness;
+
 /// A span of leaf elements in the sub-element break down of the linearization
 /// of the type tree of a type T.
 struct TypeTreeLeafTypeRange {
+  friend FieldSensitivePrunedLiveness;
   SubElementNumber startEltOffset;
   SubElementNumber endEltOffset;
 
@@ -218,6 +243,10 @@ struct TypeTreeLeafTypeRange {
   TypeTreeLeafTypeRange(SILValue rootAddress)
       : startEltOffset(0), endEltOffset(TypeSubElementCount(rootAddress)) {}
 
+  /// The leaf type range for the entire type tree.
+  TypeTreeLeafTypeRange(SILType rootType, SILFunction *fn)
+      : startEltOffset(0), endEltOffset(TypeSubElementCount(rootType, fn)) {}
+
   /// The leaf type sub-range of the type tree of \p rootAddress, consisting of
   /// \p projectedAddress and all of \p projectedAddress's descendent fields in
   /// the type tree.
@@ -234,6 +263,32 @@ struct TypeTreeLeafTypeRange {
              *startEltOffset + TypeSubElementCount(projectedAddress)}};
   }
 
+  /// Given a type \p rootType and a set of needed elements specified by the bit
+  /// vector \p neededElements, place into \p foundContiguousTypeRanges a set of
+  /// TypeTreeLeafTypeRanges that are associated with the bit vectors
+  /// elements. As a constraint, we ensure that if \p neededElements has bits
+  /// set that are part of subsequent fields of a type that is only partially
+  /// needed, the two fields are represented as separate ranges. This ensures
+  /// that it is easy to use this API to correspond to independent operations
+  /// for the fields.
+  static void convertNeededElementsToContiguousTypeRanges(
+      SILFunction *fn,
+      SILType rootType, SmallBitVector &neededElements,
+      SmallVectorImpl<TypeTreeLeafTypeRange> &foundContiguousTypeRanges);
+
+  static void constructProjectionsForNeededElements(
+      SILValue rootValue, SILInstruction *insertPt, SmallBitVector &neededElements,
+      SmallVectorImpl<SILValue> &resultingProjections);
+
+  bool operator==(const TypeTreeLeafTypeRange &other) const {
+    return startEltOffset == other.startEltOffset &&
+           endEltOffset == other.endEltOffset;
+  }
+
+  bool operator!=(const TypeTreeLeafTypeRange &other) const {
+    return !(*this == other);
+  }
+
   /// 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 {
@@ -256,6 +311,21 @@ struct TypeTreeLeafTypeRange {
     // Othrwise, see if endEltOffset - 1 is within the range.
     return startEltOffset <= rangeLastElt && rangeLastElt < endEltOffset;
   }
+
+  IntRange<unsigned> getRange() const {
+    return range(startEltOffset, endEltOffset);
+  }
+
+  bool empty() const { return startEltOffset == endEltOffset; }
+
+  unsigned size() const { return endEltOffset - startEltOffset; }
+
+  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);
 };
 
 /// This is exactly like pruned liveness except that instead of tracking a
@@ -265,7 +335,7 @@ struct TypeTreeLeafTypeRange {
 /// DISCUSSION: One can view a type T as a tree with recursively each field F of
 /// the type T being a child of T in the tree. We say recursively since the tree
 /// unfolds for F and its children as well.
-class FieldSensitiveAddressPrunedLiveness {
+class FieldSensitivePrunedLiveness {
   PrunedLiveBlocks liveBlocks;
 
   struct InterestingUser {
@@ -295,14 +365,14 @@ class FieldSensitiveAddressPrunedLiveness {
   llvm::SmallMapVector<SILInstruction *, InterestingUser, 8> users;
 
   /// The root address of our type tree.
-  SILValue rootAddress;
+  SILValue rootValue;
 
 public:
-  FieldSensitiveAddressPrunedLiveness(
+  FieldSensitivePrunedLiveness(
       SILFunction *fn, SILValue rootValue,
       SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
       : liveBlocks(TypeSubElementCount(rootValue), discoveredBlocks),
-        rootAddress(rootValue) {}
+        rootValue(rootValue) {}
 
   bool empty() const {
     assert(!liveBlocks.empty() || users.empty());
@@ -314,10 +384,15 @@ class FieldSensitiveAddressPrunedLiveness {
     users.clear();
   }
 
-  SILValue getRootAddress() const { return rootAddress; }
+  SILValue getRootValue() const { return rootValue; }
+  SILType getRootType() const { return rootValue->getType(); }
 
   unsigned numLiveBlocks() const { return liveBlocks.numLiveBlocks(); }
 
+  TypeTreeLeafTypeRange getTopLevelSpan() const {
+    return TypeTreeLeafTypeRange(0, getNumSubElements());
+  }
+
   /// If the constructor was provided with a vector to populate, then this
   /// returns the list of all live blocks with no duplicates.
   ArrayRef<SILBasicBlock *> getDiscoveredBlocks() const {
@@ -396,49 +471,142 @@ class FieldSensitiveAddressPrunedLiveness {
   }
 
   unsigned getNumSubElements() const { return liveBlocks.getNumBitsToTrack(); }
-
-  /// Return true if \p inst occurs before the liveness boundary. Used when the
-  /// client already knows that inst occurs after the start of liveness.
-  void isWithinBoundary(SILInstruction *inst, SmallBitVector &outVector) const;
 };
 
-/// Record the last use points and CFG edges that form the boundary of
-/// FieldSensitiveAddressPrunedLiveness. It does this on a per type tree leaf
-/// node basis.
-struct FieldSensitiveAddressPrunedLivenessBoundary {
-  /// The list of last users and an associated SILValue that is the address that
-  /// is being used. The address can be used to determine the start sub element
-  /// number of the user in the type tree and the end sub element number.
+template <typename LivenessWithDefs>
+class FieldSensitivePrunedLiveRange : public FieldSensitivePrunedLiveness {
+  const LivenessWithDefs &asImpl() const {
+    return reinterpret_cast<const LivenessWithDefs &>(*this);
+  }
+
+public:
+  FieldSensitivePrunedLiveRange(
+      SILFunction *fn, SILValue rootValue,
+      SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
+      : FieldSensitivePrunedLiveness(fn, rootValue, discoveredBlocks) {}
+
+  /// Check if \p inst occurs in between the definition of a def and the
+  /// liveness boundary for bits in \p span.
   ///
-  /// TODO (MG): If we don't eventually need to store the SILValue here (I am
-  /// not sure yet...), just store a tuple with the start/end sub element
-  /// number.
-  SmallVector<std::tuple<SILInstruction *, TypeTreeLeafTypeRange>, 8> lastUsers;
+  /// NOTE: It is assumed that \p inst is correctly described by span.
+  bool isWithinBoundary(SILInstruction *inst, TypeTreeLeafTypeRange span) const __attribute__((optnone));
+};
+
+/// Single defined liveness.
+///
+// An SSA def results in pruned liveness with a contiguous liverange.
+///
+/// An unreachable self-loop might result in a "gap" between the last use above
+/// the def in the same block.
+///
+/// For SSA live ranges, a single "def" block dominates all uses. If no def
+/// block is provided, liveness is computed as if defined by a function
+/// argument. If the client does not provide a single, dominating def block,
+/// then the client must at least ensure that no uses precede the first
+/// definition in a def block. Since this analysis does not remember the
+/// positions of defs, it assumes that, within a block, uses follow
+/// defs. Breaking this assumption will result in a "hole" in the live range in
+/// which the def block's predecessors incorrectly remain dead. This situation
+/// could be handled by adding an updateForUseBeforeFirstDef() API.
+class FieldSensitiveSSAPrunedLiveRange
+    : public FieldSensitivePrunedLiveRange<FieldSensitiveSSAPrunedLiveRange> {
+  std::pair<SILValue, Optional<TypeTreeLeafTypeRange>> def = {{}, {}};
+
+  /// None for arguments.
+  std::pair<SILInstruction *, Optional<TypeTreeLeafTypeRange>> defInst = {
+      nullptr, None};
+
+public:
+  FieldSensitiveSSAPrunedLiveRange(
+      SILFunction *fn, SILValue rootValue,
+      SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
+      : FieldSensitivePrunedLiveRange(fn, rootValue, discoveredBlocks) {}
 
-  /// Blocks where the value was live out but had a successor that was dead.
-  SmallVector<SILBasicBlock *, 8> boundaryEdges;
+  std::pair<SILValue, Optional<TypeTreeLeafTypeRange>> getDef() const {
+    return def;
+  }
 
   void clear() {
-    lastUsers.clear();
-    boundaryEdges.clear();
+    def = {{}, {}};
+    defInst = {{}, {}};
+    FieldSensitivePrunedLiveRange::clear();
   }
 
-  /// 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 compute(const FieldSensitiveAddressPrunedLiveness &liveness);
+  void initializeDef(SILValue def, TypeTreeLeafTypeRange span) {
+    assert(!this->def.first && !this->def.second && "reinitialization");
 
-private:
-  void
-  findLastUserInBlock(SILBasicBlock *bb,
-                      FieldSensitiveAddressPrunedLivenessBoundary &boundary,
-                      const FieldSensitiveAddressPrunedLiveness &liveness,
-                      unsigned subElementNumber);
+    this->def = {def, span};
+    defInst = {def->getDefiningInstruction(), span};
+    initializeDefBlock(def->getParentBlock(), span);
+  }
+
+  bool isInitialized() const { return bool(def.first) && bool(def.second); }
+
+  bool isDef(SILInstruction *inst, unsigned bit) const {
+    return inst == defInst.first && defInst.second->contains(bit);
+  }
+
+  bool isDefBlock(SILBasicBlock *block, unsigned bit) const {
+    return def.first->getParentBlock() == block && def.second->contains(bit);
+  }
+};
+
+/// MultiDefPrunedLiveness is computed incrementally by calling updateForUse.
+///
+/// Defs should be initialized before calling updatingForUse on any def
+/// that reaches the use.
+class FieldSensitiveMultiDefPrunedLiveRange
+    : public FieldSensitivePrunedLiveRange<
+          FieldSensitiveMultiDefPrunedLiveRange> {
+  // TODO: See if we can make this more efficient.
+  llvm::SmallMapVector<SILNode *, TypeTreeLeafTypeRange, 8> defs;
+  llvm::SmallMapVector<SILBasicBlock *, TypeTreeLeafTypeRange, 8> defBlocks;
+
+public:
+  FieldSensitiveMultiDefPrunedLiveRange(
+      SILFunction *fn, SILValue rootValue,
+      SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
+      : FieldSensitivePrunedLiveRange(fn, rootValue, discoveredBlocks) {}
+
+  void clear() { llvm_unreachable("multi-def liveness cannot be reused"); }
+
+  void initializeDef(SILValue def, TypeTreeLeafTypeRange span) {
+    defs.insert({def, span});
+    auto *block = def->getParentBlock();
+    defBlocks.insert({block, span});
+    initializeDefBlock(block, span);
+  }
+
+  void initializeDef(SILInstruction *def, TypeTreeLeafTypeRange span) {
+    defs.insert({cast<SILNode>(def), span});
+    auto *block = def->getParent();
+    defBlocks.insert({block, span});
+    initializeDefBlock(block, span);
+  }
+
+  bool isInitialized() const { return !defs.empty(); }
+
+  /// Return true if this block is a def block for this specific bit.
+  bool isDefBlock(SILBasicBlock *block, unsigned bit) const {
+    auto iter = defBlocks.find(block);
+    if (iter == defBlocks.end())
+      return false;
+    return iter->second.contains(bit);
+  }
+
+  bool isDef(SILInstruction *inst, unsigned bit) const {
+    auto iter = defs.find(cast<SILNode>(inst));
+    if (iter == defs.end())
+      return false;
+    return iter->second.contains(bit);
+  }
+
+  bool isDef(SILValue value, unsigned bit) const {
+    auto iter = defs.find(cast<SILNode>(value));
+    if (iter == defs.end())
+      return false;
+    return iter->second.contains(bit);
+  }
 };
 
 } // namespace swift

include/swift/SIL/SILType.h

@@ -495,6 +495,8 @@ class SILType {
   SILType getFieldType(VarDecl *field, SILModule &M,
                        TypeExpansionContext context) const;
 
+  SILType getFieldType(VarDecl *field, SILFunction *fn) const;
+
   /// Given that this is an enum type, return the lowered type of the
   /// data for the given element.  Applies substitutions as necessary.
   /// The result will have the same value category as the base type.

lib/SIL/IR/SILType.cpp

@@ -320,6 +320,10 @@ SILType SILType::getFieldType(VarDecl *field, SILModule &M,
   return getFieldType(field, M.Types, context);
 }
 
+SILType SILType::getFieldType(VarDecl *field, SILFunction *fn) const {
+  return getFieldType(field, fn->getModule(), fn->getTypeExpansionContext());
+}
+
 SILType SILType::getEnumElementType(EnumElementDecl *elt, TypeConverter &TC,
                                     TypeExpansionContext context) const {
   assert(elt->getDeclContext() == getEnumOrBoundGenericEnum());