Give bind_memory a token result.

Required for UnsafeRawPointer.withMemoryRebound(to:)

%token = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T

%0 must be of $Builtin.RawPointer type

%1 must be of $Builtin.Word type

%token is an opaque $Builtin.Word representing the previously bound types
for this memory region.

Author: atrick

docs/SIL.rst

@@ -3985,13 +3985,21 @@ bind_memory
 
   sil-instruction ::= 'bind_memory' sil-operand ',' sil-operand 'to' sil-type
 
-  bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T
+  %token = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T
   // %0 must be of $Builtin.RawPointer type
   // %1 must be of $Builtin.Word type
+  // %token is an opaque $Builtin.Word representing the previously bound types
+  // for this memory region.
 
 Binds memory at ``Builtin.RawPointer`` value ``%0`` to type ``$T`` with enough
 capacity to hold ``%1`` values. See SE-0107: UnsafeRawPointer.
 
+Produces a opaque token representing the previous memory state. For
+memory binding semantics, this state includes the type that the memory
+was previously bound to. The token cannot, however, be used to
+retrieve a metatype. It's value is only meaningful to the Swift
+runtime for typed pointer verification.
+
 begin_access
 ````````````
 

include/swift/AST/Builtins.def

@@ -452,7 +452,10 @@ BUILTIN_SIL_OPERATION(BeginCOWMutation_native, "beginCOWMutation_native", Specia
 /// inout argument. After calling this builtin, the buffer must not be mutated.
 BUILTIN_SIL_OPERATION(EndCOWMutation, "endCOWMutation", Special)
 
-/// bindMemory : <T> (Builtin.RawPointer, Builtin.Word, T.Type) -> ()
+/// bindMemory : <T> (Builtin.RawPointer, Builtin.Word, T.Type) -> Builtin.Word
+///
+/// Binds memory to a statically known type. Returns an opaque token
+/// representing the memory region's previously bound types.
 BUILTIN_SIL_OPERATION(BindMemory, "bindMemory", Special)
 
 /// allocWithTailElems_<n>(C.Type,

include/swift/SIL/SILInstruction.h

@@ -4866,14 +4866,16 @@ class CopyAddrInst
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
 };
 
-/// BindMemoryInst -
-/// "bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T"
+/// "%token = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T"
+///
 /// Binds memory at the raw pointer %0 to type $T with enough capacity
-/// to hold $1 values.
-class BindMemoryInst final :
-    public InstructionBaseWithTrailingOperands<
-                                          SILInstructionKind::BindMemoryInst,
-                                          BindMemoryInst, NonValueInstruction> {
+/// to hold %1 values.
+///
+/// %token is an opaque word representing the previously bound types of this
+/// memory region, before binding it to a contiguous region of type $T.
+class BindMemoryInst final : public InstructionBaseWithTrailingOperands<
+                                 SILInstructionKind::BindMemoryInst,
+                                 BindMemoryInst, SingleValueInstruction> {
   friend SILBuilder;
 
   SILType BoundType;
@@ -4883,10 +4885,11 @@ class BindMemoryInst final :
     SILFunction &F);
 
   BindMemoryInst(SILDebugLocation Loc, SILValue Base, SILValue Index,
-                 SILType BoundType,
+                 SILType BoundType, SILType TokenType,
                  ArrayRef<SILValue> TypeDependentOperands)
-    : InstructionBaseWithTrailingOperands(Base, Index, TypeDependentOperands,
-                                          Loc), BoundType(BoundType) {}
+      : InstructionBaseWithTrailingOperands(Base, Index, TypeDependentOperands,
+                                            Loc, TokenType),
+        BoundType(BoundType) {}
 
 public:
   enum { BaseOperIdx, IndexOperIdx, NumFixedOpers };

include/swift/SIL/SILNodes.def

@@ -750,9 +750,14 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(KeyPathInst, keypath,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 
-  SINGLE_VALUE_INST_RANGE(SingleValueInstruction, AllocStackInst, KeyPathInst)
+  // BindMemory has no physical side effect. Semantically it writes to
+  // its affected memory region because any reads or writes accessing
+  // that memory must be dependent on the bind operation.
+  SINGLE_VALUE_INST(BindMemoryInst, bind_memory,
+                    SILInstruction, MayWrite, DoesNotRelease)
 
-NODE_RANGE(ValueBase, SILPhiArgument, KeyPathInst)
+SINGLE_VALUE_INST_RANGE(SingleValueInstruction, AllocStackInst, BindMemoryInst)
+NODE_RANGE(ValueBase, SILPhiArgument, BindMemoryInst)
 
 // Terminators
 ABSTRACT_INST(TermInst, SILInstruction)
@@ -840,12 +845,6 @@ ABSTRACT_INST(RefCountingInst, SILInstruction)
        DoesNotRelease)
   INST_RANGE(RefCountingInst, StrongRetainInst, AutoreleaseValueInst)
 
-// BindMemory has no physical side effect. Semantically it writes to
-// its affected memory region because any reads or writes accessing
-// that memory must be dependent on the bind operation.
-NON_VALUE_INST(BindMemoryInst, bind_memory,
-               SILInstruction, MayWrite, DoesNotRelease)
-
 // FIXME: Is MayHaveSideEffects appropriate?
 BRIDGED_NON_VALUE_INST(FixLifetimeInst, fix_lifetime,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)

lib/AST/Builtins.cpp

@@ -888,12 +888,15 @@ static ValueDecl *getEndCOWMutation(ASTContext &ctx, Identifier id) {
 }
 
 static ValueDecl *getBindMemoryOperation(ASTContext &ctx, Identifier id) {
-  return getBuiltinFunction(ctx, id, _thin,
-                            _generics(_unrestricted),
-                            _parameters(_rawPointer,
-                                        _word,
-                                        _metatype(_typeparam(0))),
-                            _void);
+  FuncDecl *fd = getBuiltinFunction(ctx, id, _thin,
+                                    _generics(_unrestricted),
+                                    _parameters(_rawPointer,
+                                                _word,
+                                                _metatype(_typeparam(0))),
+                                    _word);
+  fd->getAttrs().add(new (ctx) DiscardableResultAttr(/*implicit*/true));
+  return fd;
+}
 }
 
 static ValueDecl *getAllocWithTailElemsOperation(ASTContext &Context,

lib/SIL/IR/SILInstructions.cpp

@@ -1144,12 +1144,14 @@ CopyAddrInst::CopyAddrInst(SILDebugLocation Loc, SILValue SrcLValue,
 BindMemoryInst *
 BindMemoryInst::create(SILDebugLocation Loc, SILValue Base, SILValue Index,
                        SILType BoundType, SILFunction &F) {
+  auto tokenTy = SILType::getBuiltinWordType(F.getASTContext());
   SmallVector<SILValue, 8> TypeDependentOperands;
-  collectTypeDependentOperands(TypeDependentOperands, F, BoundType.getASTType());
+  collectTypeDependentOperands(TypeDependentOperands, F,
+                               BoundType.getASTType());
   auto Size = totalSizeToAlloc<swift::Operand>(TypeDependentOperands.size() +
                                                NumFixedOpers);
   auto Buffer = F.getModule().allocateInst(Size, alignof(BindMemoryInst));
-  return ::new (Buffer) BindMemoryInst(Loc, Base, Index, BoundType,
+  return ::new (Buffer) BindMemoryInst(Loc, Base, Index, BoundType, tokenTy,
                                        TypeDependentOperands);
 }
 

lib/SIL/IR/ValueOwnership.cpp

@@ -94,6 +94,7 @@ CONSTANT_OWNERSHIP_INST(Owned, ObjCMetatypeToObject)
 CONSTANT_OWNERSHIP_INST(None, AddressToPointer)
 CONSTANT_OWNERSHIP_INST(None, AllocStack)
 CONSTANT_OWNERSHIP_INST(None, BeginAccess)
+CONSTANT_OWNERSHIP_INST(None, BindMemory)
 CONSTANT_OWNERSHIP_INST(None, BridgeObjectToWord)
 CONSTANT_OWNERSHIP_INST(None, ClassMethod)
 CONSTANT_OWNERSHIP_INST(None, ClassifyBridgeObject)

lib/SILGen/SILGenBuiltin.cpp

@@ -961,16 +961,16 @@ static ManagedValue emitBuiltinBindMemory(SILGenFunction &SGF,
                                           ArrayRef<ManagedValue> args,
                                           SGFContext C) {
   assert(subs.getReplacementTypes().size() == 1 && "bindMemory should have a single substitution");
-  assert(args.size() == 3 && "bindMemory should have three argument");
+  assert(args.size() == 3 && "bindMemory should have three arguments");
 
   // The substitution determines the element type for bound memory.
   CanType boundFormalType = subs.getReplacementTypes()[0]->getCanonicalType();
   SILType boundType = SGF.getLoweredType(boundFormalType);
 
-  SGF.B.createBindMemory(loc, args[0].getValue(),
-                         args[1].getValue(), boundType);
+  auto *bindMemory = SGF.B.createBindMemory(loc, args[0].getValue(),
+                                            args[1].getValue(), boundType);
 
-  return ManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
+  return ManagedValue::forUnmanaged(bindMemory);
 }
 
 static ManagedValue emitBuiltinAllocWithTailElems(SILGenFunction &SGF,

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 642; // Type Sequence Bits in Generic Parameters
+const uint16_t SWIFTMODULE_VERSION_MINOR = 643; // bind_memory tokens
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

test/SIL/Parser/basic.sil

@@ -1611,7 +1611,7 @@ bb0(%0 : $Builtin.RawPointer, %1 : $X):
 // CHECK-LABEL: sil @test_bind_memory
 sil @test_bind_memory : $(Builtin.RawPointer, Builtin.Word) -> () {
 bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.Word):
-  bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $*X
+  %2 = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $*X
   // CHECK: bind_memory {{%.*}} : $Builtin.RawPointer, {{%.*}} : $Builtin.Word to $*X
   %28 = tuple ()
   return %28 : $()

test/SILGen/builtins.swift

@@ -791,7 +791,7 @@ func unsafeGuaranteedEnd(_ t: Builtin.Int8) {
 
 // CHECK-LABEL: sil hidden [ossa] @$s8builtins10bindMemory{{[_0-9a-zA-Z]*}}F
 // CHECK: bb0([[P:%.*]] : $Builtin.RawPointer, [[I:%.*]] : $Builtin.Word, [[T:%.*]] : $@thick T.Type):
-// CHECK: bind_memory [[P]] : $Builtin.RawPointer, [[I]] : $Builtin.Word to $*T
+// CHECK: %{{.*}} = bind_memory [[P]] : $Builtin.RawPointer, [[I]] : $Builtin.Word to $*T
 // CHECK:   return {{%.*}} : $()
 // CHECK: }
 func bindMemory<T>(ptr: Builtin.RawPointer, idx: Builtin.Word, _: T.Type) {

test/SILOptimizer/redundant_load_elim_with_casts.sil

@@ -115,10 +115,10 @@ bb0(%0 : $Builtin.RawPointer, %1 : $A2):
   %2 = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*A
   %3 = load %2 : $*A
   %4 = integer_literal $Builtin.Word, 1
-  bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $A2
-  %5 = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*A2
-  store %1 to %5 : $*A2
-  bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $A
+  %5 = bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $A2
+  %6 = pointer_to_address %0 : $Builtin.RawPointer to [strict] $*A2
+  store %1 to %6 : $*A2
+  %8 = bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $A
   %20 = load %2 : $*A
   %30 = tuple(%3 : $A, %20 : $A)
   return %30 : $(A, A)

test/SILOptimizer/retain_release_code_motion.sil

@@ -808,7 +808,7 @@ sil @testCopyArray : $@convention(thin) (_ContiguousArrayBuffer<AnyObject>, Buil
 bb0(%0 : $_ContiguousArrayBuffer<AnyObject>, %1 : $Builtin.Word, %2 : $Builtin.Word):
   %eltty = metatype $@thick AnyObject.Protocol
   %newptr = builtin "allocRaw"(%1 : $Builtin.Word, %1 : $Builtin.Word) : $Builtin.RawPointer
-  bind_memory %newptr : $Builtin.RawPointer, %1 : $Builtin.Word to $*AnyObject
+  %token = bind_memory %newptr : $Builtin.RawPointer, %1 : $Builtin.Word to $*AnyObject
   %storage = struct_extract %0 : $_ContiguousArrayBuffer<AnyObject>, #_ContiguousArrayBuffer._storage
   %elements = ref_tail_addr %storage : $__ContiguousArrayStorageBase, $AnyObject
   %eltptr = address_to_pointer %elements : $*AnyObject to $Builtin.RawPointer

test/SILOptimizer/specialize.sil

@@ -563,7 +563,7 @@ sil hidden @test_bind : $@convention(thin) <T> (Builtin.RawPointer, @thick T.Typ
 bb0(%0 : $Builtin.RawPointer, %1 : $@thick T.Type):
   %4 = integer_literal $Builtin.Word, 1
   %5 = metatype $@thick T.Type
-  bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $*T
+  %6 = bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $*T
   %7 = tuple ()
   %8 = tuple ()
   return %8 : $()

test/SILOptimizer/specialize_ossa.sil

@@ -611,7 +611,7 @@ sil hidden [ossa] @test_bind : $@convention(thin) <T> (Builtin.RawPointer, @thic
 bb0(%0 : $Builtin.RawPointer, %1 : $@thick T.Type):
   %4 = integer_literal $Builtin.Word, 1
   %5 = metatype $@thick T.Type
-  bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $*T
+  %6 = bind_memory %0 : $Builtin.RawPointer, %4 : $Builtin.Word to $*T
   %7 = tuple ()
   %8 = tuple ()
   return %8 : $()

test/Serialization/Inputs/def_basic.sil

@@ -1050,8 +1050,8 @@ bb0(%0 : $Builtin.RawPointer, %1 : $X):
 // CHECK-LABEL: sil public_external [transparent] [serialized] @test_bind_memory
 sil [transparent] [serialized] @test_bind_memory : $@convention(thin) (Builtin.RawPointer, Builtin.Word) -> () {
 bb0(%0 : $Builtin.RawPointer, %1 : $Builtin.Word):
-  bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $*X
-  // CHECK: bind_memory {{%.*}} : $Builtin.RawPointer, {{%.*}} : $Builtin.Word to $*X
+  %2 = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $*X
+  // CHECK: %2 = bind_memory {{%.*}} : $Builtin.RawPointer, {{%.*}} : $Builtin.Word to $*X
   %28 = tuple ()
   return %28 : $()
 }