Add verification to make sure guaranteed forwarding phi has guaranteed forwarding operands on all paths

Author: meg-gupta

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -145,6 +145,8 @@ class SILValueOwnershipChecker {
   bool isSubobjectProjectionWithLifetimeEndingUses(
       SILValue value,
       const SmallVectorImpl<Operand *> &lifetimeEndingUsers) const;
+  bool hasGuaranteedForwardingIncomingPhiOperandsOnZeroOrAllPaths(
+      SILPhiArgument *phi) const;
 };
 
 } // namespace swift
@@ -623,6 +625,39 @@ bool SILValueOwnershipChecker::isSubobjectProjectionWithLifetimeEndingUses(
   });
 }
 
+bool SILValueOwnershipChecker::
+    hasGuaranteedForwardingIncomingPhiOperandsOnZeroOrAllPaths(
+        SILPhiArgument *phi) const {
+  bool foundGuaranteedForwardingPhiOperand = false;
+  bool foundNonGuaranteedForwardingPhiOperand = false;
+  phi->visitTransitiveIncomingPhiOperands([&](auto *, auto *operand) -> bool {
+    auto value = operand->get();
+    if (canOpcodeForwardInnerGuaranteedValues(value) ||
+        isa<SILFunctionArgument>(value)) {
+      foundGuaranteedForwardingPhiOperand = true;
+      if (foundNonGuaranteedForwardingPhiOperand) {
+        return false; /* found error, stop visiting */
+      }
+      return true;
+    }
+    foundNonGuaranteedForwardingPhiOperand = true;
+    if (foundGuaranteedForwardingPhiOperand) {
+      return false; /* found error, stop visiting */
+    }
+    return true;
+  });
+  if (foundGuaranteedForwardingPhiOperand ^
+      foundNonGuaranteedForwardingPhiOperand) {
+    return true;
+  }
+  return errorBuilder.handleMalformedSIL([&] {
+    llvm::errs() << "Malformed @guaranteed phi!\n"
+                 << "Phi: " << *phi;
+    llvm::errs() << "Guaranteed forwarding operand on one path and reborrow "
+                    "on another!\n";
+  });
+}
+
 bool SILValueOwnershipChecker::checkUses() {
   LLVM_DEBUG(llvm::dbgs() << "    Gathering and classifying uses!\n");
 
@@ -685,6 +720,13 @@ bool SILValueOwnershipChecker::checkUses() {
       return false;
     }
   }
+  auto *phi = dyn_cast<SILPhiArgument>(value);
+  if (phi && phi->isPhi() &&
+      phi->getOwnershipKind() == OwnershipKind::Guaranteed) {
+    if (!hasGuaranteedForwardingIncomingPhiOperandsOnZeroOrAllPaths(phi)) {
+      return false;
+    }
+  }
 
   if (isa<LoadBorrowInst>(value) || isa<BeginBorrowInst>(value)) {
     guaranteedPhiVerifier.verifyGuaranteedForwardingPhis(BorrowedValue(value));

test/SIL/OwnershipVerifier/guaranteed_phis_errors.sil

@@ -180,6 +180,32 @@ bb2(%phi : @guaranteed $SuperKlass):
   return %9999 : $()
 }
 
+// CHECK: Error#: 0. Begin Error in Function: 'test7'
+// CHECK: Malformed @guaranteed phi!
+// CHECK: Phi: %7 = argument of bb3 : $SuperKlass
+// CHECK: Guaranteed forwarding operand on one path and reborrow on another!
+// CHECK: Error#: 0. End Error in Function: 'test7'
+sil [ossa] @test7 : $@convention(thin) (@guaranteed Klass, @owned SuperKlass) -> () {
+bb0(%0 : @guaranteed $Klass, %1 : @owned $SuperKlass):
+  cond_br undef, bb1, bb2
+
+bb1:
+  %3 = unchecked_ref_cast %0 : $Klass to $SuperKlass
+  br bb3(%3 : $SuperKlass)
+
+bb2:
+  %5 = begin_borrow %1 : $SuperKlass
+  br bb3(%5 : $SuperKlass)
+
+bb3(%7 : @guaranteed $SuperKlass):
+  %8 = function_ref @use_superklass : $@convention(thin) (@guaranteed SuperKlass) -> ()
+  %9 = apply %8(%7) : $@convention(thin) (@guaranteed SuperKlass) -> ()
+  end_borrow %7 : $SuperKlass
+  destroy_value %1 : $SuperKlass
+  %12 = tuple ()
+  return %12 : $()
+}
+
 enum FakeOptional<T> {
   case none
   case some(T)

test/SILOptimizer/copy_propagation_canonicalize_with_reborrows.sil

@@ -149,7 +149,8 @@ sil [ossa] @nohoist_destroy_over_reborrow_loop : $@convention(thin) () -> () {
 entry:
   %none1 = enum $FakeOptional<X>, #FakeOptional.none!enumelt
   %none2 = enum $FakeOptional<X>, #FakeOptional.none!enumelt
-  br head(%none2 : $FakeOptional<X>, %none1 : $FakeOptional<X>)
+  %none_borrow_2 = begin_borrow %none2 : $FakeOptional<X>
+  br head(%none_borrow_2 : $FakeOptional<X>, %none1 : $FakeOptional<X>)
 
 head(%reborrow : @guaranteed $FakeOptional<X>, %value : @owned $FakeOptional<X>):
   cond_br undef, body, exit