[ownership] Allow for the ownership verifier to be run in non-asserts builds if -sil-verify-all is set.

This is matching the behavior of the rest of the verifier. NOTE: Both early exit
if said flag is not set, so this should not hit compile time in any way unless
the flag is set (in which case someone is asking for more verification...).

While I was here, I also noticed an ancillary bug where we were not checking if
a value was from in a block that was in a SILGlobalVariable or a SILFunction. We
already had a check that stopped this early when validating ownership of
SILInstructions. I guess we have never had a situation where the verifier was
given values to run on SILGlobalVariable blocks.

Author: gottesmm

include/swift/SIL/SILValue.h

@@ -387,6 +387,18 @@ class SILValue {
           NumLowBitsAvailable
   };
 
+  /// If this SILValue is a result of an instruction, return its
+  /// defining instruction. Returns nullptr otherwise.
+  SILInstruction *getDefiningInstruction() {
+    return Value->getDefiningInstruction();
+  }
+
+  /// If this SILValue is a result of an instruction, return its
+  /// defining instruction. Returns nullptr otherwise.
+  const SILInstruction *getDefiningInstruction() const {
+    return Value->getDefiningInstruction();
+  }
+
   /// Returns the ValueOwnershipKind that describes this SILValue's ownership
   /// semantics if the SILValue has ownership semantics. Returns is a value
   /// without any Ownership Semantics.

lib/SIL/SILOwnershipVerifier.cpp

@@ -569,13 +569,19 @@ bool SILValueOwnershipChecker::checkUses() {
 //===----------------------------------------------------------------------===//
 
 void SILInstruction::verifyOperandOwnership() const {
-#ifndef NDEBUG
   if (DisableOwnershipVerification)
     return;
 
   if (isStaticInitializerInst())
     return;
 
+#ifdef NDEBUG
+  // When compiling without asserts enabled, only verify ownership if
+  // -sil-verify-all is set.
+  if (!getModule().getOptions().VerifyAll)
+    return;
+#endif
+
   // If SILOwnership is not enabled, do not perform verification.
   if (!getModule().getOptions().VerifySILOwnership)
     return;
@@ -631,14 +637,27 @@ void SILInstruction::verifyOperandOwnership() const {
            "At this point, we are expected to assert");
     llvm_unreachable("triggering standard assertion failure routine");
   }
-#endif
 }
 
 void SILValue::verifyOwnership(DeadEndBlocks *deadEndBlocks) const {
-#ifndef NDEBUG
   if (DisableOwnershipVerification)
     return;
 
+#ifdef NDEBUG
+  // When compiling without asserts enabled, only verify ownership if
+  // -sil-verify-all is set.
+  if (!getModule().getOptions().VerifyAll)
+    return;
+#endif
+
+  // Make sure that we are not a value of an instruction in a SILGlobalVariable
+  // block.
+  if (auto *definingInst = getDefiningInstruction()) {
+    if (definingInst->isStaticInitializerInst()) {
+      return;
+    }
+  }
+
   // Since we do not have SILUndef, we now know that getFunction() should return
   // a real function. Assert in case this assumption is no longer true.
   SILFunction *f = (*this)->getFunction();
@@ -667,5 +686,4 @@ void SILValue::verifyOwnership(DeadEndBlocks *deadEndBlocks) const {
                              liveBlocks)
         .check();
   }
-#endif
 }