Check whether epilogue releases cover all non-trivial fields.

When we have all the epilogue releases. Make sure they cover all the non-trivial
parts of the base. Otherwise, treat as if we've found no releases for the base.

Currently. this is a NFC other than epilogue dumper. I will wire it up with
function signature with next commit.

This is part of rdar://22380547

Author: trentxintong

include/swift/SIL/Projection.h

@@ -36,6 +36,7 @@ namespace swift {
 
 class SILBuilder;
 class ProjectionPath;
+using ProjectionPathSet = llvm::DenseSet<ProjectionPath>;
 using ProjectionPathList = llvm::SmallVector<Optional<ProjectionPath>, 8>;
 
 enum class SubSeqRelation_t : uint8_t {
@@ -568,6 +569,11 @@ class ProjectionPath {
                                                 SILModule *Mod,
                                                 ProjectionPathList &P);
 
+  /// Return true if the given projection paths in \p CPaths does not cover
+  /// all the fields with non-trivial semantics, false otherwise.
+  static bool hasUncoveredNonTrivials(SILType B, SILModule *Mod,
+                                      ProjectionPathSet &CPaths);
+
   /// Returns true if the two paths have a non-empty symmetric
   /// difference.
   ///
@@ -945,4 +951,25 @@ class ProjectionTree {
 
 } // end swift namespace
 
+namespace llvm {
+using swift::ProjectionPath;
+/// Allow ProjectionPath to be used in DenseMap.
+template <> struct DenseMapInfo<ProjectionPath> {
+  static inline ProjectionPath getEmptyKey() {
+    return ProjectionPath(DenseMapInfo<swift::SILType>::getEmptyKey(),
+                          DenseMapInfo<swift::SILType>::getEmptyKey());
+  }
+  static inline ProjectionPath getTombstoneKey() {
+    return ProjectionPath(DenseMapInfo<swift::SILType>::getTombstoneKey(),
+                          DenseMapInfo<swift::SILType>::getTombstoneKey());
+  }
+  static inline unsigned getHashValue(const ProjectionPath &Val) {
+    return hash_value(Val);
+  }
+  static bool isEqual(const ProjectionPath &LHS, const ProjectionPath &RHS) {
+    return LHS == RHS;
+  }
+};
+} // namespace llvm
+
 #endif

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -128,6 +128,10 @@ class ConsumedArgToEpilogueReleaseMatcher {
   /// and any one the released values.
   bool isRedundantRelease(ReleaseList Insts, SILValue Base, SILValue Derived);
 
+  /// Return true if we have a release instruction for all the reference
+  /// sematics part of \p Base.
+  bool releaseAllNonTrivials(ReleaseList Insts, SILValue Base);
+
 public:
   /// Finds matching releases in the return block of the function \p F.
   ConsumedArgToEpilogueReleaseMatcher(RCIdentityFunctionInfo *RCFI,

lib/SIL/Projection.cpp

@@ -748,6 +748,60 @@ ProjectionPath::expandTypeIntoNodeProjectionPaths(SILType B, SILModule *Mod,
   } while (!Worklist.empty());
 }
 
+bool ProjectionPath::
+hasUncoveredNonTrivials(SILType B, SILModule *Mod, ProjectionPathSet &CPaths) {
+  llvm::SmallVector<ProjectionPath, 4> Worklist, Paths;
+  // Push an empty projection path to get started.
+  ProjectionPath P(B);
+  Worklist.push_back(P);
+  do {
+    // Get the next level projections based on current projection's type.
+    ProjectionPath PP = Worklist.pop_back_val();
+ 
+    // If this path is part of the covered path, then continue.
+    if (CPaths.find(PP) != CPaths.end())
+      continue;
+      
+    // Get the current type to process.
+    SILType Ty = PP.getMostDerivedType(*Mod);
+
+    // Get the first level projection of the current type.
+    llvm::SmallVector<Projection, 4> Projections;
+    Projection::getFirstLevelProjections(Ty, *Mod, Projections);
+
+    // Reached the end of the projection tree, this field can not be expanded
+    // anymore.
+    if (Projections.empty()) {
+      Paths.push_back(PP);
+      continue;
+    }
+
+    // There is at least one projection path that leads to a type with
+    // reference semantics.
+    if (Ty.getClassOrBoundGenericClass()) {
+      Paths.push_back(PP);
+      continue;
+    }
+
+    // Keep expanding the location.
+    for (auto &P : Projections) {
+      ProjectionPath X(B);
+      X.append(PP);
+      assert(PP.getMostDerivedType(*Mod) == X.getMostDerivedType(*Mod));
+      X.append(P);
+      Worklist.push_back(X);
+    }
+    // Keep iterating if the worklist is not empty.
+  } while (!Worklist.empty());
+
+  // Check whether any path leads to a non-trivial type.
+  for (auto &X : Paths) {
+    if (!X.getMostDerivedType(*Mod).isTrivial(*Mod))
+       return true;
+  }   
+  return false;
+}
+
 bool
 Projection::operator<(const Projection &Other) const {
   // If we have a nominal kind...

lib/SILOptimizer/Analysis/ARCAnalysis.cpp

@@ -502,6 +502,25 @@ isRedundantRelease(ReleaseList Insts, SILValue Base, SILValue Derived) {
   return false;
 }
 
+bool
+ConsumedArgToEpilogueReleaseMatcher::
+releaseAllNonTrivials(ReleaseList Insts, SILValue Base) {
+  // Reason about whether all parts are released.
+  SILModule *Mod = &(*Insts.begin())->getModule();
+
+  // These are the list of SILValues that are actually released.
+  ProjectionPathSet Paths;
+  for (auto &I : Insts) {
+    auto PP = ProjectionPath::getProjectionPath(Base, I->getOperand(0));
+    if (!PP)
+      return false;
+    Paths.insert(PP.getValue());
+  } 
+
+  // Is there an uncovered non-trivial type.
+  return !ProjectionPath::hasUncoveredNonTrivials(Base->getType(), Mod, Paths);
+}
+
 void ConsumedArgToEpilogueReleaseMatcher::findMatchingReleases(
     SILBasicBlock *BB) {
   // Iterate over the instructions post-order and find releases associated with
@@ -573,6 +592,17 @@ void ConsumedArgToEpilogueReleaseMatcher::findMatchingReleases(
     // Record it. 
     Iter->second.push_back(Target);
   }
+
+  // If we can not find a releases for all parts with reference semantics
+  // that means we did not find all releases for the base.
+  llvm::DenseSet<SILArgument *> ArgToRemove;
+  for (auto &Arg : ArgInstMap) {
+    if (!releaseAllNonTrivials(Arg.second, Arg.first))
+      ArgToRemove.insert(Arg.first);
+  }
+
+  for (auto &X : ArgToRemove) 
+    ArgInstMap.erase(ArgInstMap.find(X));
 }
 
 //===----------------------------------------------------------------------===//

test/SILOptimizer/epilogue_release_dumper.sil

@@ -27,6 +27,12 @@ struct baz {
   init()
 }
 
+struct boo {
+  var tbaz = baz()
+  var a = 0
+  init()
+}
+
 // CHECK-LABEL: START: sil @single_release_foo
 // CHECK: [[IN1:%.*]] = argument of bb0 : $foo
 // CHECK: strong_release [[IN1]] : $foo
@@ -80,7 +86,7 @@ bb0(%0 : $baz):
 //
 // CHECK-LABEL: START: sil @exploded_release_with_interfering_uses
 // CHECK: [[IN1:%.*]] = argument of bb0 : $baz
-// CHECK: strong_release
+// CHECK-NOT: strong_release
 // CHECK: END: sil @exploded_release_with_interfering_uses
 sil @exploded_release_with_interfering_uses : $@convention(thin) (@owned baz) -> () {
 bb0(%0 : $baz):
@@ -97,7 +103,6 @@ bb0(%0 : $baz):
 //
 // CHECK-LABEL: START: sil @exploded_release_with_overlapping_releases
 // CHECK: [[IN1:%.*]] = argument of bb0 : $baz
-// CHECK: strong_release
 // CHECK-NOT: strong_release
 // CHECK: END: sil @exploded_release_with_overlapping_releases
 sil @exploded_release_with_overlapping_releases : $@convention(thin) (@owned baz) -> () {
@@ -139,3 +144,75 @@ bb0(%0 : $foo, %1 : $bar):
   %3 = tuple ()
   return %3 : $()
 }
+
+// Make sure we stop at the redundant release.
+//
+// CHECK-LABEL: START: sil @exploded_release_with_redundant_releases
+// CHECK: [[IN1:%.*]] = argument of bb0 : $baz
+// CHECK: release_value [[IN1]]
+// CHECK: END: sil @exploded_release_with_redundant_releases
+sil @exploded_release_with_redundant_releases : $@convention(thin) (@owned baz) -> () {
+bb0(%0 : $baz):
+  %1 = struct_extract %0 : $baz, #baz.start
+  %2 = struct_extract %0 : $baz, #baz.end
+  strong_release %1 : $foo
+  strong_release %2 : $foo
+  release_value  %0 : $baz
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// Make sure we have an uncovered value type.
+//
+// CHECK-LABEL: START: sil @exploded_release_with_uncovered_value_semantics
+// CHECK: [[IN0:%.*]] = argument of bb0 : $boo
+// CHECK: release_value
+// CHECK: release_value
+// CHECK: END: sil @exploded_release_with_uncovered_value_semantics
+sil @exploded_release_with_uncovered_value_semantics : $@convention(thin) (@owned boo) -> () {
+bb0(%0 : $boo):
+  %1 = struct_extract %0 : $boo, #boo.tbaz
+  %2 = struct_extract %0 : $boo, #boo.a
+  %3 = struct_extract %1 : $baz, #baz.start
+  %4 = struct_extract %1 : $baz, #baz.end
+  release_value  %3 : $foo
+  release_value  %4 : $foo
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// Make sure we have an uncovered reference type.
+//
+// CHECK-LABEL: START: sil @exploded_release_with_uncovered_reference_semantics
+// CHECK: [[IN1:%.*]] = argument of bb0 : $boo
+// CHECK-NOT: release_value
+// CHECK: END: sil @exploded_release_with_uncovered_reference_semantics
+sil @exploded_release_with_uncovered_reference_semantics : $@convention(thin) (@owned boo) -> () {
+bb0(%0 : $boo):
+  %1 = struct_extract %0 : $boo, #boo.tbaz
+  %2 = struct_extract %0 : $boo, #boo.a
+  %3 = struct_extract %1 : $baz, #baz.start
+  %4 = struct_extract %1 : $baz, #baz.end
+  release_value  %3 : $foo
+  %5 = tuple ()
+  return %5 : $()
+}
+
+// Make sure we have an uncovered reference type due to overlapping release.
+//
+// CHECK-LABEL: START: sil @exploded_release_with_uncovered_reference_semantics_overlapping_release
+// CHECK: [[IN1:%.*]] = argument of bb0 : $boo
+// CHECK-NOT: release_value
+// CHECK: END: sil @exploded_release_with_uncovered_reference_semantics_overlapping_release
+sil @exploded_release_with_uncovered_reference_semantics_overlapping_release : $@convention(thin) (@owned boo) -> () {
+bb0(%0 : $boo):
+  %1 = struct_extract %0 : $boo, #boo.tbaz
+  %2 = struct_extract %0 : $boo, #boo.a
+  %3 = struct_extract %1 : $baz, #baz.start
+  %4 = struct_extract %1 : $baz, #baz.end
+  release_value  %4 : $foo
+  release_value  %3 : $foo
+  release_value  %3 : $foo
+  %5 = tuple ()
+  return %5 : $()
+}