Fix SILInliner to create move_value in OSSA only

Author: meg-gupta

include/swift/SIL/SILBuilder.h

@@ -1278,6 +1278,7 @@ class SILBuilder {
   }
 
   CopyValueInst *createCopyValue(SILLocation Loc, SILValue operand) {
+    assert(getFunction().hasOwnership());
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitCopyValueOperation");
@@ -1296,6 +1297,7 @@ class SILBuilder {
 
   DestroyValueInst *createDestroyValue(SILLocation Loc, SILValue operand,
                                        bool poisonRefs = false) {
+    assert(getFunction().hasOwnership());
     assert(isLoadableOrOpaque(operand->getType()));
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
@@ -1306,6 +1308,7 @@ class SILBuilder {
 
   MoveValueInst *createMoveValue(SILLocation loc, SILValue operand,
                                  bool isLexical = false) {
+    assert(getFunction().hasOwnership());
     assert(!operand->getType().isTrivial(getFunction()) &&
            "Should not be passing trivial values to this api. Use instead "
            "emitMoveValueOperation");

include/swift/SIL/SILCloner.h

@@ -1870,6 +1870,9 @@ void SILCloner<ImplClass>::visitExplicitCopyValueInst(
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitMoveValueInst(MoveValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  if (!getBuilder().hasOwnership()) {
+    return recordFoldedValue(Inst, getOpValue(Inst->getOperand()));
+  }
   auto *MVI = getBuilder().createMoveValue(getOpLocation(Inst->getLoc()),
                                            getOpValue(Inst->getOperand()),
                                            Inst->isLexical());

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -449,50 +449,58 @@ void SILInlineCloner::cloneInline(ArrayRef<SILValue> AppliedArgs) {
 
   SmallVector<SILValue, 4> entryArgs;
   entryArgs.reserve(AppliedArgs.size());
+
+  auto calleeConv = getCalleeFunction()->getConventions();
   SmallBitVector borrowedArgs(AppliedArgs.size());
   SmallBitVector copiedArgs(AppliedArgs.size());
+  if (!Apply->getFunction()->hasOwnership()) {
 
-  auto calleeConv = getCalleeFunction()->getConventions();
-  for (auto p : llvm::enumerate(AppliedArgs)) {
-    SILValue callArg = p.value();
-    SWIFT_DEFER { entryArgs.push_back(callArg); };
-    unsigned idx = p.index();
-    if (idx >= calleeConv.getSILArgIndexOfFirstParam()) {
-      auto paramInfo = calleeConv.getParamInfoForSILArg(idx);
-      if (callArg->getType().isAddress()) {
-        // If lexical lifetimes are enabled, any alloc_stacks in the caller that
-        // are passed to the callee being inlined (except mutating exclusive
-        // accesses) need to be promoted to be lexical.  Otherwise,
-        // destroy_addrs could be hoisted through the body of the newly inlined
-        // function without regard to the deinit barriers it contains.
-        //
-        // TODO: [begin_borrow_addr] Instead of marking the alloc_stack as a
-        //       whole lexical, just mark the inlined range lexical via
-        //       begin_borrow_addr [lexical]/end_borrow_addr just as is done
-        //       with values.
-        auto &module = Apply.getFunction()->getModule();
-        auto enableLexicalLifetimes =
-            module.getASTContext().SILOpts.supportsLexicalLifetimes(module);
-        if (!enableLexicalLifetimes)
-          continue;
-
-        // Exclusive mutating accesses don't entail a lexical scope.
-        if (paramInfo.getConvention() == ParameterConvention::Indirect_Inout)
-          continue;
-
-        auto storage = AccessStorageWithBase::compute(callArg);
-        if (auto *asi = dyn_cast_or_null<AllocStackInst>(storage.base))
-          asi->setIsLexical();
-      } else {
-        // Insert begin/end borrow for guaranteed arguments.
-        if (paramInfo.isGuaranteed()) {
-          if (SILValue newValue = borrowFunctionArgument(callArg, idx)) {
-            callArg = newValue;
-            borrowedArgs[idx] = true;
-          }
-        } else if (paramInfo.isConsumed()) {
-          if (SILValue newValue = moveFunctionArgument(callArg, idx)) {
-            callArg = newValue;
+    for (auto p : llvm::enumerate(AppliedArgs)) {
+      SILValue callArg = p.value();
+      entryArgs.push_back(callArg);
+    }
+  } else {
+    for (auto p : llvm::enumerate(AppliedArgs)) {
+      SILValue callArg = p.value();
+      SWIFT_DEFER { entryArgs.push_back(callArg); };
+      unsigned idx = p.index();
+      if (idx >= calleeConv.getSILArgIndexOfFirstParam()) {
+        auto paramInfo = calleeConv.getParamInfoForSILArg(idx);
+        if (callArg->getType().isAddress()) {
+          // If lexical lifetimes are enabled, any alloc_stacks in the caller
+          // that are passed to the callee being inlined (except mutating
+          // exclusive accesses) need to be promoted to be lexical.  Otherwise,
+          // destroy_addrs could be hoisted through the body of the newly
+          // inlined function without regard to the deinit barriers it contains.
+          //
+          // TODO: [begin_borrow_addr] Instead of marking the alloc_stack as a
+          //       whole lexical, just mark the inlined range lexical via
+          //       begin_borrow_addr [lexical]/end_borrow_addr just as is done
+          //       with values.
+          auto &module = Apply.getFunction()->getModule();
+          auto enableLexicalLifetimes =
+              module.getASTContext().SILOpts.supportsLexicalLifetimes(module);
+          if (!enableLexicalLifetimes)
+            continue;
+
+          // Exclusive mutating accesses don't entail a lexical scope.
+          if (paramInfo.getConvention() == ParameterConvention::Indirect_Inout)
+            continue;
+
+          auto storage = AccessStorageWithBase::compute(callArg);
+          if (auto *asi = dyn_cast_or_null<AllocStackInst>(storage.base))
+            asi->setIsLexical();
+        } else {
+          // Insert begin/end borrow for guaranteed arguments.
+          if (paramInfo.isGuaranteed()) {
+            if (SILValue newValue = borrowFunctionArgument(callArg, idx)) {
+              callArg = newValue;
+              borrowedArgs[idx] = true;
+            }
+          } else if (paramInfo.isConsumed()) {
+            if (SILValue newValue = moveFunctionArgument(callArg, idx)) {
+              callArg = newValue;
+            }
           }
         }
       }