Merge pull request #40121 from eeckstein/memorylifetimeverifier

Make the MemoryLifetimeVerifier more picky about double destroys of trivial enums

Author: eeckstein

lib/SIL/Verifier/MemoryLifetimeVerifier.cpp

@@ -67,7 +67,7 @@ class MemoryLifetimeVerifier {
 
   /// Issue an error if any bit in \p wrongBits is set.
   void require(const Bits &wrongBits, const Twine &complaint,
-                               SILInstruction *where);
+               SILInstruction *where, bool excludeTrivialEnums = false);
 
   /// Require that all the subLocation bits of the location, associated with
   /// \p addr, are clear in \p bits.
@@ -252,19 +252,20 @@ void MemoryLifetimeVerifier::reportError(const Twine &complaint,
 }
 
 void MemoryLifetimeVerifier::require(const Bits &wrongBits,
-                                const Twine &complaint, SILInstruction *where) {
+                                const Twine &complaint, SILInstruction *where,
+                                bool excludeTrivialEnums) {
   for (int errorLocIdx = wrongBits.find_first(); errorLocIdx >= 0;
        errorLocIdx = wrongBits.find_next(errorLocIdx)) {
-    if (!isEnumTrivialAt(errorLocIdx, where))
+    if (!excludeTrivialEnums || !isEnumTrivialAt(errorLocIdx, where))
       reportError(complaint, errorLocIdx, where);
   }
 }
 
 void MemoryLifetimeVerifier::requireBitsClear(const Bits &bits, SILValue addr,
                                              SILInstruction *where) {
   if (auto *loc = locations.getLocation(addr)) {
-    require(bits & loc->subLocations,
-            "memory is initialized, but shouldn't", where);
+    require(bits & loc->subLocations, "memory is initialized, but shouldn't",
+            where, /*excludeTrivialEnums*/ true);
   }
 }
 
@@ -502,7 +503,8 @@ void MemoryLifetimeVerifier::checkFunction(BitDataflow &dataFlow) {
       BlockState &predState = dataFlow[pred];
       if (predState.reachableFromEntry) {
         require((bs.data.entrySet ^ predState.exitSet) & nonTrivialLocations,
-          "lifetime mismatch in predecessors", pred->getTerminator());
+          "lifetime mismatch in predecessors", pred->getTerminator(),
+          /*excludeTrivialEnums*/ true);
       }
     }
 
@@ -515,13 +517,15 @@ void MemoryLifetimeVerifier::checkFunction(BitDataflow &dataFlow) {
         require(expectedReturnBits & ~bs.data.exitSet,
           "indirect argument is not alive at function return", term);
         require(bs.data.exitSet & ~expectedReturnBits & nonTrivialLocations,
-          "memory is initialized at function return but shouldn't", term);
+          "memory is initialized at function return but shouldn't", term,
+           /*excludeTrivialEnums*/ true);
         break;
       case SILInstructionKind::ThrowInst:
         require(expectedThrowBits & ~bs.data.exitSet,
           "indirect argument is not alive at throw", term);
         require(bs.data.exitSet & ~expectedThrowBits & nonTrivialLocations,
-          "memory is initialized at throw but shouldn't", term);
+          "memory is initialized at throw but shouldn't", term,
+           /*excludeTrivialEnums*/ true);
         break;
       default:
         break;

test/SIL/memory_lifetime_failures.sil

@@ -600,3 +600,39 @@ bb3:
   %15 = tuple ()
   return %15 : $()
 }
+
+// CHECK: SIL memory lifetime failure in @test_double_enum_destroy: memory is not initialized, but should
+sil [ossa] @test_double_enum_destroy : $@convention(thin) (@in Optional<String>) -> () {
+bb0(%0 : $*Optional<String>):
+  %l = load_borrow %0 : $*Optional<String>
+  switch_enum %l : $Optional<String>, case #Optional.some!enumelt: bb1, case #Optional.none!enumelt: bb2 
+
+bb1(%a : @guaranteed $String):
+  end_borrow %l : $Optional<String>
+  %2 = load [take] %0 : $*Optional<String>
+  destroy_value %2 : $Optional<String>
+  br bb3 
+
+bb2:
+  end_borrow %l : $Optional<String>
+  %3 = load [take] %0 : $*Optional<String>
+  destroy_value %3 : $Optional<String>
+  %4 = load [take] %0 : $*Optional<String>
+  destroy_value %4 : $Optional<String>
+  br bb3 
+
+bb3:
+  %r = tuple ()
+  return %r : $() 
+}
+
+// CHECK: SIL memory lifetime failure in @test_destroy_enum_before_return: indirect argument is not alive at function return
+sil [ossa] @test_destroy_enum_before_return : $@convention(thin) () -> @out Optional<String> {
+bb0(%0 : $*Optional<String>):
+  %1 = enum $Optional<String>, #Optional.none!enumelt
+  store %1 to [trivial] %0 : $*Optional<String>
+  destroy_addr %0 : $*Optional<String>
+  %r = tuple ()
+  return %r : $() 
+}
+