[moveOnly] Implement a semi-generic _move function that can be used on non-generic, non-existential values.

This patch introduces a new stdlib function called _move:

```Swift
  @_alwaysEmitIntoClient
  @_transparent
  @_semantics("lifetimemanagement.move")
  public func _move<T>(_ value: __owned T) -> T {
  #if $ExperimentalMoveOnly
    Builtin.move(value)
  #else
    value
  #endif
  }
```

It is a first attempt at creating a "move" function for Swift, albeit a skleton
one since we do not yet perform the "no use after move" analysis. But this at
leasts gets the skeleton into place so we can built the analysis on top of it
and churn tree in a manageable way. Thus in its current incarnation, all it does
is take in an __owned +1 parameter and returns it after moving it through
Builtin.move.

Given that we want to use an OSSA based analysis for our "no use after move"
analysis and we do not have opaque values yet, we can not supporting moving
generic values since they are address only. This has stymied us in the past from
creating this function. With the implementation in this PR via a bit of
cleverness, we are now able to support this as a generic function over all
concrete types by being a little clever.

The trick is that when we transparent inline _move (to get the builtin), we
perform one level of specialization causing the inlined Builtin.move to be of a
loadable type. If after transparent inlining, we inline builtin "move" into a
context where it is still address only, we emit a diagnostic telling the user
that they applied move to a generic or existential and that this is not yet
supported.

The reason why we are taking this approach is that we wish to use this to
implement a new (as yet unwritten) diagnostic pass that verifies that _move
(even for non-trivial copyable values) ends the lifetime of the value. This will
ensure that one can write the following code to reliably end the lifetime of a
let binding in Swift:

```Swift
  let x = Klass()
  let _ = _move(x)
  // hypotheticalUse(x)
```

Without the diagnostic pass, if one were to write another hypothetical use of x
after the _move, the compiler would copy x to at least hypotheticalUse(x)
meaning the lifetime of x would not end at the _move, =><=.

So to implement this diagnostic pass, we want to use the OSSA infrastructure and
that only works on objects! So how do we square this circle: by taking advantage
of the mandatory SIL optimzier pipeline! Specifically we take advantage of the
following:

1. Mandatory Inlining and Predictable Dead Allocation Elimination run before any
   of the move only diagnostic passes that we run.

2. Mandatory Inlining is able to specialize a callee a single level when it
   inlines code. One can take advantage of this to even at -Onone to
   monomorphosize code.

and then note that _move is such a simple function that predictable dead
allocation elimination is able to without issue eliminate the extra alloc_stack
that appear in the caller after inlining without issue. So we (as the tests
show) get SIL that for concrete types looks exactly like we just had run a
move_value for that specific type as an object since we promote away the
stores/loads in favor of object operations when we eliminate the allocation.

In order to prevent any issue with this being used in a context where multiple
specializations may occur, I made the inliner emit a diagnostic if it inlines
_move into a function that applies it to an address only value. The diagnostic
is emitted at the source location where the function call occurs so it is easy
to find, e.x.:

```
func addressOnlyMove<T>(t: T) -> T {
    _move(t) // expected-error {{move() used on a generic or existential value}}
}

moveonly_builtin_generic_failure.swift:12:5: error: move() used on a generic or existential value
    _move(t)
    ^
```

To eliminate any potential ABI impact, if someone calls _move in a way that
causes it to be used in a context where the transparent inliner will not inline
it, I taught IRGen that Builtin.move is equivalent to a take from src -> dst and
marked _move as always emit into client (AEIC). I also took advantage of the
feature flag I added in the previous commit in order to prevent any cond_fails
from exposing Builtin.move in the stdlib. If one does not pass in the flag
-enable-experimental-move-only then the function just returns the value without
calling Builtin.move, so we are safe.

rdar://83957028

Author: gottesmm

include/swift/AST/Builtins.def

@@ -515,9 +515,6 @@ BUILTIN_SIL_OPERATION(WithUnsafeThrowingContinuation, "withUnsafeThrowingContinu
 /// Force the current task to be rescheduled on the specified actor.
 BUILTIN_SIL_OPERATION(HopToActor, "hopToActor", None)
 
-/// Generate a move_value instruction to convert a T to a @_moveOnly T.
-BUILTIN_SIL_OPERATION(Move, "move", Special)
-
 #undef BUILTIN_SIL_OPERATION
 
 // BUILTIN_RUNTIME_CALL - A call into a runtime function.
@@ -780,6 +777,19 @@ BUILTIN_MISC_OPERATION(CreateTaskGroup,
 BUILTIN_MISC_OPERATION(DestroyTaskGroup,
                        "destroyTaskGroup", "", Special)
 
+
+/// A builtin that can only be called from a transparent generic function. Takes
+/// two operands, the first operand the result address, the second operand the
+/// input address. Transforms into load [take] + move_value + store [init] when
+/// transparently inlined into a caller that has the generic of the callee
+/// specialized into a loadable type. If the transparent inlining does not
+/// specialize the type (due to being inlined into a non-generic context, the
+/// SILVerifier will abort).
+///
+/// Illegal to call except for in Swift._move in the stdlib. This is enforced by
+/// the SILVerifier.
+BUILTIN_MISC_OPERATION(Move, "move", "", Special)
+
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
 //

include/swift/AST/DiagnosticsSIL.def

@@ -686,5 +686,9 @@ NOTE(capturepromotion_concurrentcapture_capturinguse_here, none,
 NOTE(capturepromotion_variable_defined_here,none,
      "variable defined here", ())
 
+// move operator used on generic or evalue
+ERROR(move_operator_used_on_generic_or_existential_value, none,
+      "move() used on a generic or existential value", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/SemanticAttrs.def

@@ -113,5 +113,7 @@ SEMANTICS_ATTR(FORCE_EMIT_OPT_REMARK_PREFIX, "optremark")
 /// for testing purposes.
 SEMANTICS_ATTR(OBJC_FORBID_ASSOCIATED_OBJECTS, "objc.forbidAssociatedObjects")
 
+SEMANTICS_ATTR(LIFETIMEMANAGEMENT_MOVE, "lifetimemanagement.move")
+
 #undef SEMANTICS_ATTR
 

include/swift/SIL/SILType.h

@@ -620,6 +620,9 @@ class SILType {
   /// Get the SIL token type.
   static SILType getSILTokenType(const ASTContext &C);
 
+  /// Return '()'
+  static SILType getEmptyTupleType(const ASTContext &C);
+
   //
   // Utilities for treating SILType as a pointer-like type.
   //

lib/AST/Builtins.cpp

@@ -856,8 +856,7 @@ static ValueDecl *getDestroyArrayOperation(ASTContext &ctx, Identifier id) {
 
 static ValueDecl *getMoveOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin, _generics(_unrestricted),
-                            _parameters(_owned(_typeparam(0))),
-                            _moveOnly(_typeparam(0)));
+                            _parameters(_owned(_typeparam(0))), _typeparam(0));
 }
 
 static ValueDecl *getTransferArrayOperation(ASTContext &ctx, Identifier id) {

lib/IRGen/GenBuiltin.cpp

@@ -1308,5 +1308,16 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::Move) {
+    auto input = args.claimNext();
+    auto result = args.claimNext();
+    SILType addrTy = argTypes[0];
+    const TypeInfo &addrTI = IGF.getTypeInfo(addrTy);
+    Address inputAttr = addrTI.getAddressForPointer(input);
+    Address resultAttr = addrTI.getAddressForPointer(result);
+    addrTI.initializeWithTake(IGF, resultAttr, inputAttr, addrTy, false);
+    return;
+  }
+
   llvm_unreachable("IRGen unimplemented for this builtin!");
 }

lib/SIL/IR/OperandOwnership.cpp

@@ -775,6 +775,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, PoundAssert)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GlobalStringTablePointer)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, TypePtrAuthDiscriminator)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, IntInstrprofIncrement)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Move)
 BUILTIN_OPERAND_OWNERSHIP(DestroyingConsume, StartAsyncLet)
 BUILTIN_OPERAND_OWNERSHIP(DestroyingConsume, EndAsyncLet)
 BUILTIN_OPERAND_OWNERSHIP(DestroyingConsume, StartAsyncLetWithLocalBuffer)

lib/SIL/IR/SILType.cpp

@@ -94,6 +94,10 @@ SILType SILType::getOptionalType(SILType type) {
   return getPrimitiveType(CanType(optType), type.getCategory());
 }
 
+SILType SILType::getEmptyTupleType(const ASTContext &C) {
+  return getPrimitiveObjectType(C.TheEmptyTupleType);
+}
+
 SILType SILType::getSILTokenType(const ASTContext &C) {
   return getPrimitiveObjectType(C.TheSILTokenType);
 }

lib/SIL/IR/ValueOwnership.cpp

@@ -556,6 +556,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, StartAsyncLetWithLocalBuffer)
 CONSTANT_OWNERSHIP_BUILTIN(None, EndAsyncLetLifetime)
 CONSTANT_OWNERSHIP_BUILTIN(None, CreateTaskGroup)
 CONSTANT_OWNERSHIP_BUILTIN(None, DestroyTaskGroup)
+CONSTANT_OWNERSHIP_BUILTIN(None, Move)
 
 #undef CONSTANT_OWNERSHIP_BUILTIN
 

lib/SIL/Utils/MemAccessUtils.cpp

@@ -2135,6 +2135,12 @@ static void visitBuiltinAddress(BuiltinInst *builtin,
       visitor(&builtin->getAllOperands()[2]);
       return;
 
+    // This consumes its second parameter (the arg) and takes/places that value
+    // into the first parameter (the result).
+    case BuiltinValueKind::Move:
+      visitor(&builtin->getAllOperands()[1]);
+      return;
+
     // These consume values out of their second operand.
     case BuiltinValueKind::ResumeNonThrowingContinuationReturning:
     case BuiltinValueKind::ResumeThrowingContinuationReturning:

lib/SIL/Verifier/SILVerifier.cpp

@@ -20,10 +20,12 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SemanticAttrs.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Range.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/ApplySite.h"
+#include "swift/SIL/BasicBlockBits.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/Dominance.h"
@@ -32,7 +34,6 @@
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/PostOrder.h"
 #include "swift/SIL/PrettyStackTrace.h"
-#include "swift/SIL/BasicBlockBits.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
@@ -1984,6 +1985,22 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                         "result of build*ExecutorRef");
       return;
     }
+
+    if (builtinKind == BuiltinValueKind::Move) {
+      // We expect that this builtin will be specialized during transparent
+      // inlining into move_value if we inline into a non-generic context. If
+      // the builtin still remains and is not in the specific move semantic
+      // function (which is the only function marked with
+      // semantics::LIFETIMEMANAGEMENT_MOVE), then we know that we did
+      // transparent inlining into a function that did not result in the Builtin
+      // being specialized out which is user error.
+      //
+      // NOTE: Once we have opaque values, this restriction will go away. This
+      // is just so we can call Builtin.move outside of the stdlib.
+      auto semanticName = semantics::LIFETIMEMANAGEMENT_MOVE;
+      require(BI->getFunction()->hasSemanticsAttr(semanticName),
+              "_move used within a generic context");
+    }
   }
 
   void checkFunctionRefBaseInst(FunctionRefBaseInst *FRI) {

lib/SILGen/SILGenBuiltin.cpp

@@ -1578,15 +1578,6 @@ static ManagedValue emitBuiltinHopToActor(SILGenFunction &SGF, SILLocation loc,
   return ManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
 }
 
-static ManagedValue emitBuiltinMove(SILGenFunction &SGF, SILLocation loc,
-                                    SubstitutionMap subs,
-                                    ArrayRef<ManagedValue> args, SGFContext C) {
-  assert(args.size() == 1 && "Move has a single argument");
-  auto firstArg = args[0].ensurePlusOne(SGF, loc);
-  CleanupCloner cloner(SGF, firstArg);
-  return cloner.clone(SGF.B.createMoveValue(loc, firstArg.forward(SGF)));
-}
-
 static ManagedValue emitBuiltinAutoDiffCreateLinearMapContext(
     SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
     ArrayRef<ManagedValue> args, SGFContext C) {

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -174,6 +174,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::AssignCopyArrayBackToFront:
     case BuiltinValueKind::AssignTakeArray:
     case BuiltinValueKind::UnsafeGuaranteed:
+    case BuiltinValueKind::Move:
     case BuiltinValueKind::UnsafeGuaranteedEnd:
     case BuiltinValueKind::CancelAsyncTask:
     case BuiltinValueKind::StartAsyncLet:

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -13,13 +13,16 @@
 #define DEBUG_TYPE "sil-inliner"
 
 #include "swift/SILOptimizer/Utils/SILInliner.h"
+#include "swift/AST/Builtins.h"
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILDebugScope.h"
 #include "swift/SIL/TypeSubstCloner.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
 #include "swift/SILOptimizer/Utils/SILOptFunctionBuilder.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
+
 using namespace swift;
 
 static bool canInlineBeginApply(BeginApplyInst *BA) {
@@ -289,6 +292,7 @@ class SILInlineCloner
   void visitHopToExecutorInst(HopToExecutorInst *Inst);
 
   void visitTerminator(SILBasicBlock *BB);
+  void visitBuiltinInst(BuiltinInst *BI);
 
   /// This hook is called after either of the top-level visitors:
   /// cloneReachableBlocks or cloneSILFunction.
@@ -628,6 +632,7 @@ void SILInlineCloner::visitDebugValueInst(DebugValueInst *Inst) {
 
   return SILCloner<SILInlineCloner>::visitDebugValueInst(Inst);
 }
+
 void SILInlineCloner::visitHopToExecutorInst(HopToExecutorInst *Inst) {
   // Drop hop_to_executor in non async functions.
   if (!Apply.getFunction()->isAsync()) {
@@ -637,6 +642,7 @@ void SILInlineCloner::visitHopToExecutorInst(HopToExecutorInst *Inst) {
 
   return SILCloner<SILInlineCloner>::visitHopToExecutorInst(Inst);
 }
+
 const SILDebugScope *
 SILInlineCloner::getOrCreateInlineScope(const SILDebugScope *CalleeScope) {
   if (!CalleeScope)
@@ -665,6 +671,55 @@ SILInlineCloner::getOrCreateInlineScope(const SILDebugScope *CalleeScope) {
   return InlinedScope;
 }
 
+template <typename... T, typename... U>
+static void diagnose(ASTContext &Context, SourceLoc loc, Diag<T...> diag,
+                     U &&...args) {
+  Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
+}
+
+void SILInlineCloner::visitBuiltinInst(BuiltinInst *Inst) {
+  if (IKind == InlineKind::MandatoryInline) {
+    if (auto kind = Inst->getBuiltinKind()) {
+      if (*kind == BuiltinValueKind::Move) {
+        auto otherResultAddr = getOpValue(Inst->getOperand(0));
+        auto otherSrcAddr = getOpValue(Inst->getOperand(1));
+        auto otherType = otherSrcAddr->getType();
+
+        if (!otherType.isLoadable(*Inst->getFunction())) {
+          // If otherType is not loadable, emit a diagnostic since it was used
+          // on a generic or existential value.
+          diagnose(Inst->getModule().getASTContext(),
+                   getOpLocation(Inst->getLoc()).getSourceLoc(),
+                   diag::move_operator_used_on_generic_or_existential_value);
+          return SILCloner<SILInlineCloner>::visitBuiltinInst(Inst);
+        }
+
+        // If our otherType is loadable, convert it to move_value.
+        getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+        // We stash otherValue in originalOtherValue in case we need to
+        // perform a writeback.
+        auto opLoc = getOpLocation(Inst->getLoc());
+
+        assert(otherType.isAddress());
+
+        SILValue otherValue = getBuilder().emitLoadValueOperation(
+            opLoc, otherSrcAddr, LoadOwnershipQualifier::Take);
+
+        auto *mvi = getBuilder().createMoveValue(opLoc, otherValue);
+
+        getBuilder().emitStoreValueOperation(opLoc, mvi, otherResultAddr,
+                                             StoreOwnershipQualifier::Init);
+
+        // We know that Inst returns a tuple value that isn't used by anything
+        // else, so this /should/ be safe.
+        return recordClonedInstruction(Inst, mvi);
+      }
+    }
+  }
+
+  return SILCloner<SILInlineCloner>::visitBuiltinInst(Inst);
+}
+
 //===----------------------------------------------------------------------===//
 //                                 Cost Model
 //===----------------------------------------------------------------------===//

stdlib/public/core/LifetimeManager.swift

@@ -166,4 +166,31 @@ extension String {
   }
 }
 
-
+/// Takes in a value at +1 and performs a Builtin.move upon it.
+///
+/// IMPLEMENTATION NOTES: During transparent inlining, Builtin.move becomes the
+/// move_value instruction if we are inlining into a context where the
+/// specialized type is loadable. If the transparent function is called in a
+/// context where the inlined function specializes such that the specialized
+/// type is still not loadable, the compiler aborts (a). Once we have opaque
+/// values, this restriction will be lifted since after that address only types
+/// at SILGen time will be loadable objects.
+///
+/// (a). This is implemented by requiring that Builtin.move only be called
+/// within a function marked with the semantic tag "lifetimemanagement.move"
+/// which conveniently is only the function we are defining here: _move.
+///
+/// NOTE: We mark this _alwaysEmitIntoClient to ensure that we are not creating
+/// new ABI that the stdlib must maintain if a user calls this ignoring the '_'
+/// implying it is stdlib SPI.
+@_alwaysEmitIntoClient
+@inlinable
+@_transparent
+@_semantics("lifetimemanagement.move")
+func _move<T>(_ value: __owned T) -> T {
+    #if $BuiltinMove
+        Builtin.move(value)
+    #else
+        value
+    #endif
+}

test/SILGen/moveonly_builtin.swift

@@ -1,4 +1,5 @@
-// RUN: %target-swift-emit-silgen -module-name moveonly -parse-stdlib %s -disable-access-control -disable-objc-attr-requires-foundation-module | %FileCheck %s
+// RUN: %target-swift-emit-silgen -module-name moveonly -parse-stdlib %s -disable-access-control -disable-objc-attr-requires-foundation-module -enable-experimental-move-only | %FileCheck %s
+// RUN: %target-swift-emit-sil -module-name moveonly -parse-stdlib %s -disable-access-control -disable-objc-attr-requires-foundation-module -enable-experimental-move-only | %FileCheck -check-prefix=CHECK-SIL %s
 
 import Swift
 
@@ -7,21 +8,55 @@ class Klass {}
 // CHECK-LABEL: sil hidden [ossa] @$s8moveonly7useMoveyAA5KlassCADF : $@convention(thin) (@guaranteed Klass) -> @owned Klass {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK-NEXT: debug_value
-// CHECK-NEXT: copy_value
-// CHECK-NEXT: move_value
-// CHECK-NEXT: return
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = alloc_stack $Klass
+// CHECK-NEXT: [[ARC_COPY:%.*]] = copy_value [[ARG]]
+// CHECK-NEXT: [[INPUT_ADDR:%.*]] = alloc_stack $Klass
+// CHECK-NEXT: store [[ARC_COPY]] to [init] [[INPUT_ADDR]]
+// CHECK-NEXT: // function_ref _move<A>(_:)
+// CHECK-NEXT: [[MOVE:%.*]] = function_ref @$ss5_moveyxxnlF : $@convention(thin) <τ_0_0> (@in τ_0_0) -> @out τ_0_0
+// CHECK-NEXT: [[APPLY_RESULT:%.*]] = apply [[MOVE]]<Klass>([[RESULT_ADDR]], [[INPUT_ADDR]])
+// CHECK-NEXT: dealloc_stack [[INPUT_ADDR]]
+// CHECK-NEXT: [[RELOADED_VALUE:%.*]] = load [take] [[RESULT_ADDR]]
+// CHECK-NEXT: dealloc_stack [[RESULT_ADDR]]
+// CHECK-NEXT: return [[RELOADED_VALUE]]
 // CHECK: } // end sil function '$s8moveonly7useMoveyAA5KlassCADF'
+
+// CHECK-SIL-LABEL: sil hidden @$s8moveonly7useMoveyAA5KlassCADF : $@convention(thin) (@guaranteed Klass) -> @owned Klass {
+// CHECK-SIL: bb0([[ARG:%.*]] :
+// CHECK-SIL-NEXT: debug_value
+// CHECK-SIL-NEXT: strong_retain
+// CHECK-SIL-NEXT: move_value
+// CHECK-SIL-NEXT: tuple
+// CHECK-SIL-NEXT: return
+// CHECK-SIL: } // end sil function '$s8moveonly7useMoveyAA5KlassCADF'
 func useMove(_ k: Klass) -> Klass {
-    Builtin.move(k)
+    _move(k)
 }
 
 // CHECK-LABEL: sil hidden [ossa] @$s8moveonly7useMoveyxxRlzClF : $@convention(thin) <T where T : AnyObject> (@guaranteed T) -> @owned T {
 // CHECK: bb0([[ARG:%.*]] :
 // CHECK-NEXT: debug_value
-// CHECK-NEXT: copy_value
-// CHECK-NEXT: move_value
-// CHECK-NEXT: return
+// CHECK-NEXT: [[RESULT_ADDR:%.*]] = alloc_stack $T
+// CHECK-NEXT: [[ARC_COPY:%.*]] = copy_value [[ARG]]
+// CHECK-NEXT: [[INPUT_ADDR:%.*]] = alloc_stack $T
+// CHECK-NEXT: store [[ARC_COPY]] to [init] [[INPUT_ADDR]]
+// CHECK-NEXT: // function_ref _move<A>(_:)
+// CHECK-NEXT: [[MOVE:%.*]] = function_ref @$ss5_moveyxxnlF : $@convention(thin) <τ_0_0> (@in τ_0_0) -> @out τ_0_0
+// CHECK-NEXT: [[APPLY_RESULT:%.*]] = apply [[MOVE]]<T>([[RESULT_ADDR]], [[INPUT_ADDR]])
+// CHECK-NEXT: dealloc_stack [[INPUT_ADDR]]
+// CHECK-NEXT: [[RELOADED_VALUE:%.*]] = load [take] [[RESULT_ADDR]]
+// CHECK-NEXT: dealloc_stack [[RESULT_ADDR]]
+// CHECK-NEXT: return [[RELOADED_VALUE]]
 // CHECK: } // end sil function '$s8moveonly7useMoveyxxRlzClF'
+
+// CHECK-SIL-LABEL: sil hidden @$s8moveonly7useMoveyxxRlzClF : $@convention(thin) <T where T : AnyObject> (@guaranteed T) -> @owned T {
+// CHECK-SIL: bb0([[ARG:%.*]] :
+// CHECK-SIL-NEXT: debug_value
+// CHECK-SIL-NEXT: strong_retain
+// CHECK-SIL-NEXT: move_value
+// CHECK-SIL-NEXT: tuple
+// CHECK-SIL-NEXT: return
+// CHECK-SIL: } // end sil function '$s8moveonly7useMoveyxxRlzClF'
 func useMove<T : AnyObject>(_ k: T) -> T {
-    Builtin.move(k)
+    _move(k)
 }