Add checkOperandOwnershipInvariants for OSSA verification

A place to define invariants on OperandOwnership that passes can rely
on for convenience.

Starting with a simple invariant the OperandOwnership::Borrow is a
valid BorrowingOperand.

Author: atrick

include/swift/SIL/SILValue.h

@@ -904,6 +904,9 @@ inline bool canAcceptUnownedValue(OperandOwnership operandOwnership) {
   llvm_unreachable("covered switch");
 }
 
+/// Return true if all OperandOwnership invariants hold.
+bool checkOperandOwnershipInvariants(const Operand *operand);
+
 /// Return the OperandOwnership for a forwarded operand when the forwarding
 /// operation has this "forwarding ownership" (as returned by
 /// getForwardingOwnershipKind()). \p allowUnowned is true for a subset of

lib/SIL/IR/OperandOwnership.cpp

@@ -19,6 +19,16 @@
 
 using namespace swift;
 
+/// Return true if all OperandOwnership invariants hold.
+bool swift::checkOperandOwnershipInvariants(const Operand *operand) {
+  OperandOwnership opOwnership = operand->getOperandOwnership();
+  if (opOwnership == OperandOwnership::Borrow) {
+    // Must be a valid BorrowingOperand.
+    return bool(BorrowingOperand::get(operand));
+  }
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //                         OperandOwnershipClassifier
 //===----------------------------------------------------------------------===//

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -735,21 +735,31 @@ void SILInstruction::verifyOperandOwnership() const {
     if (isTypeDependentOperand(op))
       continue;
 
-    if (op.satisfiesConstraints())
-      continue;
+    if (!checkOperandOwnershipInvariants(&op)) {
+      errorBuilder->handleMalformedSIL([&] {
+        llvm::errs() << "Found an operand with invalid invariants.\n";
+        llvm::errs() << "Value: " << op.get();
+        llvm::errs() << "Instruction:\n";
+        printInContext(llvm::errs());
+        llvm::errs() << "OperandOwnership: " << op.getOperandOwnership()
+                     << "\n";
+      });
+    }
 
-    auto constraint = op.getOwnershipConstraint();
-    SILValue opValue = op.get();
-    auto valueOwnershipKind = opValue.getOwnershipKind();
-    errorBuilder->handleMalformedSIL([&] {
-      llvm::errs() << "Found an operand with a value that is not compatible "
-                      "with the operand's operand ownership kind map.\n";
-      llvm::errs() << "Value: " << opValue;
-      llvm::errs() << "Value Ownership Kind: " << valueOwnershipKind << "\n";
-      llvm::errs() << "Instruction:\n";
-      printInContext(llvm::errs());
-      llvm::errs() << "Constraint: " << constraint << "\n";
-    });
+    if (!op.satisfiesConstraints()) {
+      auto constraint = op.getOwnershipConstraint();
+      SILValue opValue = op.get();
+      auto valueOwnershipKind = opValue.getOwnershipKind();
+      errorBuilder->handleMalformedSIL([&] {
+        llvm::errs() << "Found an operand with a value that is not compatible "
+                        "with the operand's operand ownership kind map.\n";
+        llvm::errs() << "Value: " << opValue;
+        llvm::errs() << "Value Ownership Kind: " << valueOwnershipKind << "\n";
+        llvm::errs() << "Instruction:\n";
+        printInContext(llvm::errs());
+        llvm::errs() << "Constraint: " << constraint << "\n";
+      });
+    }
   }
 }