Allow SIL convention overriding in operand ownership verification

This lets the SILBuilder's verification continue to run during
address lowering before the SIL stage has been updated.

Author: atrick

include/swift/SIL/SILBuilder.h

@@ -2690,7 +2690,7 @@ class SILBuilder {
     // sync. We don't care if an instruction is used in global_addr.
     if (F)
       TheInst->verifyDebugInfo();
-    TheInst->verifyOperandOwnership();
+    TheInst->verifyOperandOwnership(&C.silConv);
 #endif
   }
 

include/swift/SIL/SILInstruction.h

@@ -773,7 +773,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
 
   /// Verify that all operands of this instruction have compatible ownership
   /// with this instruction.
-  void verifyOperandOwnership() const;
+  void verifyOperandOwnership(SILModuleConventions *silConv = nullptr) const;
 
   /// Verify that this instruction and its associated debug information follow
   /// all SIL debug info invariants.

include/swift/SIL/SILValue.h

@@ -46,6 +46,7 @@ class ConsumingUseIterator;
 class NonConsumingUseIterator;
 class NonTypeDependentUseIterator;
 class SILValue;
+class SILModuleConventions;
 
 /// An enumeration which contains values for all the concrete ValueBase
 /// subclasses.
@@ -922,7 +923,8 @@ inline bool canAcceptUnownedValue(OperandOwnership operandOwnership) {
 }
 
 /// Return true if all OperandOwnership invariants hold.
-bool checkOperandOwnershipInvariants(const Operand *operand);
+bool checkOperandOwnershipInvariants(const Operand *operand,
+                                     SILModuleConventions *silConv = nullptr);
 
 /// Return the OperandOwnership for a forwarded operand when the forwarding
 /// operation has this "forwarding ownership" (as returned by
@@ -1039,22 +1041,25 @@ class Operand {
   /// Return the use ownership of this operand.
   ///
   /// NOTE: This is implemented in OperandOwnership.cpp.
-  OperandOwnership getOperandOwnership() const;
+  OperandOwnership
+  getOperandOwnership(SILModuleConventions *silConv = nullptr) const;
 
   /// Return the ownership constraint that restricts what types of values this
   /// Operand can contain.
-  OwnershipConstraint getOwnershipConstraint() const {
-    return getOperandOwnership().getOwnershipConstraint();
+  OwnershipConstraint
+  getOwnershipConstraint(SILModuleConventions *silConv = nullptr) const {
+    return getOperandOwnership(silConv).getOwnershipConstraint();
   }
 
   /// Returns true if changing the operand to use a value with the given
   /// ownership kind, without rewriting the instruction, would not cause the
   /// operand to violate the operand's ownership constraints.
-  bool canAcceptKind(ValueOwnershipKind kind) const;
+  bool canAcceptKind(ValueOwnershipKind kind,
+                     SILModuleConventions *silConv = nullptr) const;
 
   /// Returns true if this operand and its value satisfy the operand's
   /// operand constraint.
-  bool satisfiesConstraints() const;
+  bool satisfiesConstraints(SILModuleConventions *silConv = nullptr) const;
 
   /// Returns true if this operand acts as a use that ends the lifetime its
   /// associated value, either by consuming the owned value or ending the

lib/SIL/IR/OperandOwnership.cpp

@@ -20,8 +20,9 @@
 using namespace swift;
 
 /// Return true if all OperandOwnership invariants hold.
-bool swift::checkOperandOwnershipInvariants(const Operand *operand) {
-  OperandOwnership opOwnership = operand->getOperandOwnership();
+bool swift::checkOperandOwnershipInvariants(const Operand *operand,
+                                            SILModuleConventions *silConv) {
+  OperandOwnership opOwnership = operand->getOperandOwnership(silConv);
   if (opOwnership == OperandOwnership::Borrow) {
     // Must be a valid BorrowingOperand.
     return bool(BorrowingOperand(const_cast<Operand *>(operand)));
@@ -38,6 +39,9 @@ namespace {
 class OperandOwnershipClassifier
   : public SILInstructionVisitor<OperandOwnershipClassifier, OperandOwnership> {
   LLVM_ATTRIBUTE_UNUSED SILModule &mod;
+  // Allow module conventions to be overriden while lowering between canonical
+  // and lowered SIL stages.
+  SILModuleConventions silConv;
 
   const Operand &op;
 
@@ -49,8 +53,8 @@ class OperandOwnershipClassifier
   /// should be the subobject and Value should be the parent object. An example
   /// of where one would want to do this is in the case of value projections
   /// like struct_extract.
-  OperandOwnershipClassifier(SILModule &mod, const Operand &op)
-      : mod(mod), op(op) {}
+  OperandOwnershipClassifier(SILModuleConventions silConv, const Operand &op)
+      : mod(silConv.getModule()), silConv(silConv), op(op) {}
 
   SILValue getValue() const { return op.get(); }
 
@@ -474,9 +478,17 @@ OperandOwnershipClassifier::visitFullApply(FullApplySite apply) {
   if (getValue()->getType().isAddress()) {
     return OperandOwnership::TrivialUse;
   }
-  SILArgumentConvention argConv = apply.isCalleeOperand(op)
-    ? SILArgumentConvention(apply.getSubstCalleeType()->getCalleeConvention())
-    : apply.getArgumentConvention(op);
+  auto calleeTy = apply.getSubstCalleeType();
+  SILArgumentConvention argConv = [&]() {
+    if (apply.isCalleeOperand(op)) {
+      return SILArgumentConvention(calleeTy->getCalleeConvention());
+    } else {
+      unsigned calleeArgIdx = apply.getCalleeArgIndexOfFirstAppliedArg()
+                              + apply.getAppliedArgIndex(op);
+      return silConv.getFunctionConventions(calleeTy).getSILArgumentConvention(
+          calleeArgIdx);
+    }
+  }();
 
   auto argOwnership = getFunctionArgOwnership(
     argConv, /*hasScopeInCaller*/ apply.beginsCoroutineEvaluation());
@@ -904,8 +916,9 @@ OperandOwnership OperandOwnershipClassifier::visitBuiltinInst(BuiltinInst *bi) {
 //                            Top Level Entrypoint
 //===----------------------------------------------------------------------===//
 
-OperandOwnership Operand::getOperandOwnership() const {
-  // A type-dependent operant is a NonUse (as opposed to say an
+OperandOwnership
+Operand::getOperandOwnership(SILModuleConventions *silConv) const {
+  // A type-dependent operand is a NonUse (as opposed to say an
   // InstantaneousUse) because it does not require liveness.
   if (isTypeDependent())
     return OperandOwnership::NonUse;
@@ -925,7 +938,8 @@ OperandOwnership Operand::getOperandOwnership() const {
       return OperandOwnership(OperandOwnership::InstantaneousUse);
     }
   }
-
-  OperandOwnershipClassifier classifier(getUser()->getModule(), *this);
+  SILModuleConventions overrideConv =
+      silConv ? *silConv : SILModuleConventions(getUser()->getModule());
+  OperandOwnershipClassifier classifier(overrideConv, *this);
   return classifier.visit(const_cast<SILInstruction *>(getUser()));
 }

lib/SIL/IR/SILValue.cpp

@@ -318,8 +318,9 @@ SILFunction *Operand::getParentFunction() const {
   return self->getUser()->getFunction();
 }
 
-bool Operand::canAcceptKind(ValueOwnershipKind kind) const {
-  auto operandOwnership = getOperandOwnership();
+bool Operand::canAcceptKind(ValueOwnershipKind kind,
+                            SILModuleConventions *silConv) const {
+  auto operandOwnership = getOperandOwnership(silConv);
   auto constraint = operandOwnership.getOwnershipConstraint();
   if (constraint.satisfiesConstraint(kind)) {
     // Constraints aren't precise enough to enforce Unowned value uses.
@@ -332,8 +333,8 @@ bool Operand::canAcceptKind(ValueOwnershipKind kind) const {
   return false;
 }
 
-bool Operand::satisfiesConstraints() const {
-  return canAcceptKind(get().getOwnershipKind());
+bool Operand::satisfiesConstraints(SILModuleConventions *silConv) const {
+  return canAcceptKind(get().getOwnershipKind(), silConv);
 }
 
 bool Operand::isLifetimeEnding() const {

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -687,7 +687,8 @@ bool SILValueOwnershipChecker::checkUses() {
 //                           Top Level Entrypoints
 //===----------------------------------------------------------------------===//
 
-void SILInstruction::verifyOperandOwnership() const {
+void SILInstruction::verifyOperandOwnership(
+    SILModuleConventions *silConv) const {
   if (DisableOwnershipVerification)
     return;
 
@@ -736,7 +737,7 @@ void SILInstruction::verifyOperandOwnership() const {
     if (isTypeDependentOperand(op))
       continue;
 
-    if (!checkOperandOwnershipInvariants(&op)) {
+    if (!checkOperandOwnershipInvariants(&op, silConv)) {
       errorBuilder->handleMalformedSIL([&] {
         llvm::errs() << "Found an operand with invalid invariants.\n";
         llvm::errs() << "Value: " << op.get();
@@ -747,8 +748,8 @@ void SILInstruction::verifyOperandOwnership() const {
       });
     }
 
-    if (!op.satisfiesConstraints()) {
-      auto constraint = op.getOwnershipConstraint();
+    if (!op.satisfiesConstraints(silConv)) {
+      auto constraint = op.getOwnershipConstraint(silConv);
       SILValue opValue = op.get();
       auto valueOwnershipKind = opValue.getOwnershipKind();
       errorBuilder->handleMalformedSIL([&] {