[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: