Merge pull request #40156 from atrick/rawrebound

Builtin.rebindMemory

Author: atrick

docs/SIL.rst

@@ -3985,13 +3985,41 @@ 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.
+
+rebind_memory
+`````````````
+
+::
+
+  sil-instruction ::= 'rebind_memory' sil-operand ' 'to' sil-value
+
+  %out_token = rebind_memory %0 : $Builtin.RawPointer to %in_token
+  // %0 must be of $Builtin.RawPointer type
+  // %in_token represents a cached set of bound types from a prior memory state.
+  // %out_token is an opaque $Builtin.Word representing the previously bound
+  // types for this memory region.
+
+This instruction's semantics are identical to ``bind_memory``, except
+that the types to which memory will be bound, and the extent of the
+memory region is unknown at compile time. Instead, the bound-types are
+represented by a token that was produced by a prior memory binding
+operation. ``%in_token`` must be the result of bind_memory or
+rebind_memory.
+
 begin_access
 ````````````
 

include/swift/AST/Builtins.def

@@ -452,9 +452,18 @@ 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)
 
+/// rebindMemory : (Builtin.RawPointer, Builtin.Word) -> Builtin.Word
+///
+/// Binds memory to the types represented by an opaque token operand. Returns an
+/// opaque token representing the memory region's previously bound types.
+BUILTIN_SIL_OPERATION(RebindMemory, "rebindMemory", Special)
+
 /// allocWithTailElems_<n>(C.Type,
 ///                    Builtin.Word, E1.Type, ... , Builtin.Word, En.Type) -> C\
 ///

include/swift/SIL/SILBuilder.h

@@ -1027,6 +1027,13 @@ class SILBuilder {
                                          boundType, getFunction()));
   }
 
+  RebindMemoryInst *createRebindMemory(SILLocation Loc, SILValue base,
+                                       SILValue inToken) {
+    auto tokenTy = SILType::getBuiltinWordType(F->getASTContext());
+    return insert(new (getModule()) RebindMemoryInst(getSILDebugLocation(Loc),
+                                                     base, inToken, tokenTy));
+  }
+
   ConvertFunctionInst *createConvertFunction(SILLocation Loc, SILValue Op,
                                              SILType Ty,
                                              bool WithoutActuallyEscaping) {

include/swift/SIL/SILCloner.h

@@ -1351,6 +1351,15 @@ SILCloner<ImplClass>::visitBindMemoryInst(BindMemoryInst *Inst) {
                 getOpValue(Inst->getIndex()), getOpType(Inst->getBoundType())));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitRebindMemoryInst(RebindMemoryInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createRebindMemory(getOpLocation(Inst->getLoc()),
+                                            getOpValue(Inst->getBase()),
+                                            getOpValue(Inst->getInToken())));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitConvertFunctionInst(ConvertFunctionInst *Inst) {

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 };
@@ -4906,6 +4909,38 @@ class BindMemoryInst final :
   }
 };
 
+/// "%out_token = rebind_memory
+///     %0 : $Builtin.RawPointer, %in_token : $Builtin.Word
+///
+/// Binds memory at the raw pointer %0 to the types abstractly represented by
+/// %in_token.
+///
+/// %in_token is itself the result of a bind_memory or rebind_memory and
+/// represents a previously cached set of bound types.
+///
+/// %out_token represents the previously bound types of this memory region,
+/// before binding it to %in_token.
+class RebindMemoryInst final : public SingleValueInstruction {
+  FixedOperandList<2> Operands;
+
+public:
+  enum { BaseOperIdx, InTokenOperIdx };
+
+  RebindMemoryInst(SILDebugLocation Loc, SILValue Base, SILValue InToken,
+                   SILType TokenType)
+      : SingleValueInstruction(SILInstructionKind::RebindMemoryInst, Loc,
+                               TokenType),
+        Operands{this, Base, InToken} {}
+
+public:
+  SILValue getBase() const { return getAllOperands()[BaseOperIdx].get(); }
+
+  SILValue getInToken() const { return getAllOperands()[InTokenOperIdx].get(); }
+
+  ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
+  MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+};
+
 //===----------------------------------------------------------------------===//
 // Conversion instructions.
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILNodes.def

@@ -750,9 +750,16 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(KeyPathInst, keypath,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 
-  SINGLE_VALUE_INST_RANGE(SingleValueInstruction, AllocStackInst, KeyPathInst)
+  // BindMemory and RebindMemory have no physical side effect. Semantically they
+  // write to their 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)
+  SINGLE_VALUE_INST(RebindMemoryInst, rebind_memory,
+                    SILInstruction, MayWrite, DoesNotRelease)
 
-NODE_RANGE(ValueBase, SILPhiArgument, KeyPathInst)
+SINGLE_VALUE_INST_RANGE(SingleValueInstruction, AllocStackInst, RebindMemoryInst)
+NODE_RANGE(ValueBase, SILPhiArgument, RebindMemoryInst)
 
 // Terminators
 ABSTRACT_INST(TermInst, SILInstruction)
@@ -840,12 +847,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,23 @@ 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 *getRebindMemoryOperation(ASTContext &ctx, Identifier id) {
+  FuncDecl *fd = getBuiltinFunction(ctx, id, _thin,
+                                    _parameters(_rawPointer,
+                                                _word),
+                                    _word);
+  fd->getAttrs().add(new (ctx) DiscardableResultAttr(/*implicit*/true));
+  return fd;
 }
 
 static ValueDecl *getAllocWithTailElemsOperation(ASTContext &Context,
@@ -2629,6 +2640,10 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     if (!Types.empty()) return nullptr;
     return getBindMemoryOperation(Context, Id);
 
+  case BuiltinValueKind::RebindMemory:
+    if (!Types.empty()) return nullptr;
+    return getRebindMemoryOperation(Context, Id);
+
   case BuiltinValueKind::ProjectTailElems:
     if (!Types.empty()) return nullptr;
     return getProjectTailElemsOperation(Context, Id);

lib/IRGen/IRGenSIL.cpp

@@ -1265,6 +1265,7 @@ class IRGenSILFunction :
   void visitDestroyAddrInst(DestroyAddrInst *i);
 
   void visitBindMemoryInst(BindMemoryInst *i);
+  void visitRebindMemoryInst(RebindMemoryInst *i);
 
   void visitCondFailInst(CondFailInst *i);
 
@@ -6785,10 +6786,13 @@ void IRGenSILFunction::visitCopyAddrInst(swift::CopyAddrInst *i) {
   }
 }
 
-// This is a no-op because we do not lower Swift TBAA info to LLVM IR, and it
-// does not produce any values.
+// bind_memory and rebind_memory are no-ops because Swift TBAA info is not
+// lowered to LLVM IR TBAA, and the output token is ignored except for
+// verification.
 void IRGenSILFunction::visitBindMemoryInst(swift::BindMemoryInst *) {}
 
+void IRGenSILFunction::visitRebindMemoryInst(swift::RebindMemoryInst *) {}
+
 void IRGenSILFunction::visitDestroyAddrInst(swift::DestroyAddrInst *i) {
   SILType addrTy = i->getOperand()->getType();
   const TypeInfo &addrTI = getTypeInfo(addrTy);

lib/SIL/IR/OperandOwnership.cpp

@@ -138,6 +138,7 @@ OPERAND_OWNERSHIP(TrivialUse, AllocRefDynamic) // with tail operand
 OPERAND_OWNERSHIP(TrivialUse, BeginAccess)
 OPERAND_OWNERSHIP(TrivialUse, BeginUnpairedAccess)
 OPERAND_OWNERSHIP(TrivialUse, BindMemory)
+OPERAND_OWNERSHIP(TrivialUse, RebindMemory)
 OPERAND_OWNERSHIP(TrivialUse, CheckedCastAddrBranch)
 OPERAND_OWNERSHIP(TrivialUse, CondBranch)
 OPERAND_OWNERSHIP(TrivialUse, CondFail)

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/SILPrinter.cpp

@@ -1708,7 +1708,12 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(BI->getIndex()) << " to ";
     *this << BI->getBoundType();
   }
-  
+
+  void visitRebindMemoryInst(RebindMemoryInst *BI) {
+    *this << getIDAndType(BI->getBase()) << " to ";
+    *this << getIDAndType(BI->getInToken());
+  }
+
   void visitUnconditionalCheckedCastInst(UnconditionalCheckedCastInst *CI) {
     *this << getIDAndType(CI->getOperand()) << " to " << CI->getTargetFormalType();
     printForwardingOwnershipKind(CI, CI->getOperand());

lib/SIL/IR/ValueOwnership.cpp

@@ -94,6 +94,8 @@ 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, RebindMemory)
 CONSTANT_OWNERSHIP_INST(None, BridgeObjectToWord)
 CONSTANT_OWNERSHIP_INST(None, ClassMethod)
 CONSTANT_OWNERSHIP_INST(None, ClassifyBridgeObject)

lib/SIL/Parser/ParseSIL.cpp

@@ -4768,24 +4768,29 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     }
     case SILInstructionKind::BindMemoryInst: {
       SILValue IndexVal;
-      Identifier ToToken;
-      SourceLoc ToLoc;
       SILType EltTy;
-      if (parseTypedValueRef(Val, B) ||
-          P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ",") ||
-          parseTypedValueRef(IndexVal, B) ||
-          parseSILIdentifier(ToToken, ToLoc, diag::expected_tok_in_sil_instr,
-                             "to") ||
-          parseSILType(EltTy) || parseSILDebugLocation(InstLoc, B))
+      if (parseTypedValueRef(Val, B)
+          || P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ",")
+          || parseTypedValueRef(IndexVal, B)
+          || parseVerbatim("to")
+          || parseSILType(EltTy)
+          || parseSILDebugLocation(InstLoc, B))
         return true;
 
-      if (ToToken.str() != "to") {
-        P.diagnose(ToLoc, diag::expected_tok_in_sil_instr, "to");
-        return true;
-      }
       ResultVal = B.createBindMemory(InstLoc, Val, IndexVal, EltTy);
       break;
     }
+    case SILInstructionKind::RebindMemoryInst: {
+      SILValue InToken;
+      if (parseTypedValueRef(Val, B)
+          || parseVerbatim("to")
+          || parseTypedValueRef(InToken, B)
+          || parseSILDebugLocation(InstLoc, B))
+        return true;
+
+      ResultVal = B.createRebindMemory(InstLoc, Val, InToken);
+      break;
+    }
     case SILInstructionKind::ObjectInst:
     case SILInstructionKind::StructInst: {
       SILType Ty;

lib/SIL/Utils/InstructionUtils.cpp

@@ -475,6 +475,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
   case SILInstructionKind::DeallocStackInst:
   case SILInstructionKind::AutoreleaseValueInst:
   case SILInstructionKind::BindMemoryInst:
+  case SILInstructionKind::RebindMemoryInst:
   case SILInstructionKind::FixLifetimeInst:
   case SILInstructionKind::EndBorrowInst:
   case SILInstructionKind::AssignInst:

lib/SIL/Verifier/SILVerifier.cpp

@@ -3040,6 +3040,17 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                     "bind_memory index must be a Word");
   }
 
+  void checkRebindMemoryInst(RebindMemoryInst *rbi) {
+    require(rbi->getBase()->getType().is<BuiltinRawPointerType>(),
+            "rebind_memory base be a RawPointer");
+    requireSameType(rbi->getInToken()->getType(),
+                    SILType::getBuiltinWordType(F.getASTContext()),
+                    "rebind_memory token must be a Builtin.Int64");
+    require(isa<BindMemoryInst>(rbi->getInToken())
+            || isa<RebindMemoryInst>(rbi->getInToken()),
+            "rebind_memory token must originate from bind_memory");
+  }
+
   void checkIndexAddrInst(IndexAddrInst *IAI) {
     require(IAI->getType().isAddress(), "index_addr must produce an address");
     requireSameType(