SIL: add new instruction set_deallocating

It will be used by the ReleaseDevirtualizer before calling the deallocator.
So far, this is NFC.

Author: eeckstein

Diff for: docs/SIL.rst

@@ -2300,6 +2300,21 @@ zero, the object is destroyed and ``@weak`` references are cleared.  When both
 its strong and unowned reference counts reach zero, the object's memory is
 deallocated.
 
+set_deallocating
+````````````````
+::
+
+  set_deallocating %0 : $T
+  // $T must be a reference type.
+
+Explicitly sets the state of the object referenced by ``%0`` to deallocated.
+This is the same operation what's done by a strong_release immediately before
+it calls the deallocator of the object.
+
+It is expected that the strong reference count of the object is one.
+Furthermore, no other thread may increment the strong reference count during
+execution of this instruction.
+
 strong_retain_unowned
 `````````````````````
 ::

Diff for: include/swift/Runtime/RuntimeFunctions.def

@@ -167,6 +167,13 @@ FUNCTION_WITH_GLOBAL_SYMBOL_AND_IMPL(NativeStrongReleaseN, swift_release_n,
          ARGS(RefCountedPtrTy, Int32Ty),
          ATTRS(NoUnwind))
 
+// void swift_setDeallocating(void *ptr);
+FUNCTION(NativeSetDeallocating, swift_setDeallocating,
+         DefaultCC,
+         RETURNS(VoidTy),
+         ARGS(RefCountedPtrTy),
+         ATTRS(NoUnwind))
+
 // void swift_unknownRetain_n(void *ptr, int32_t n);
 FUNCTION(UnknownRetainN, swift_unknownRetain_n,
          DefaultCC,

Diff for: include/swift/SIL/SILBuilder.h

@@ -674,6 +674,12 @@ class SILBuilder {
         getSILDebugLocation(Loc), operand));
   }
 
+  SetDeallocatingInst *createSetDeallocating(SILLocation Loc,
+                                            SILValue operand) {
+    return insert(new (F.getModule()) SetDeallocatingInst(
+        getSILDebugLocation(Loc), operand));
+  }
+
   StructInst *createStruct(SILLocation Loc, SILType Ty,
                            ArrayRef<SILValue> Elements) {
     return insert(

Diff for: include/swift/SIL/SILCloner.h

@@ -1050,6 +1050,15 @@ SILCloner<ImplClass>::visitAutoreleaseValueInst(AutoreleaseValueInst *Inst) {
                                         getOpValue(Inst->getOperand())));
 }
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitSetDeallocatingInst(SetDeallocatingInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(Inst,
+    getBuilder().createSetDeallocating(getOpLocation(Inst->getLoc()),
+                                       getOpValue(Inst->getOperand())));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitStructInst(StructInst *Inst) {

Diff for: include/swift/SIL/SILInstruction.h

@@ -2322,6 +2322,20 @@ class AutoreleaseValueInst
       : UnaryInstructionBase(DebugLoc, operand) {}
 };
 
+/// SetDeallocatingInst - Sets the operand in deallocating state.
+///
+/// This is the same operation what's done by a strong_release immediately
+/// before it calls the deallocator of the object.
+class SetDeallocatingInst
+                 : public UnaryInstructionBase<ValueKind::SetDeallocatingInst,
+                                                RefCountingInst,
+                                                /*HasValue*/ false> {
+  friend class SILBuilder;
+
+  SetDeallocatingInst(SILDebugLocation DebugLoc, SILValue operand)
+      : UnaryInstructionBase(DebugLoc, operand) {}
+};
+
 /// StrongPinInst - Ensure that the operand is retained and pinned, if
 /// not by this operation then by some enclosing pin.
 ///

Diff for: include/swift/SIL/SILNodes.def

@@ -123,6 +123,8 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
          MayRelease)
     INST(RetainValueInst, RefCountingInst, MayHaveSideEffects, DoesNotRelease)
     INST(ReleaseValueInst, RefCountingInst, MayHaveSideEffects, MayRelease)
+    INST(SetDeallocatingInst, RefCountingInst, MayHaveSideEffects,
+         DoesNotRelease)
     INST(AutoreleaseValueInst, RefCountingInst, MayHaveSideEffects,
          DoesNotRelease)
     VALUE_RANGE(RefCountingInst, StrongRetainInst, AutoreleaseValueInst)

Diff for: include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t 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.
 /// describe what change you made.
-const uint16_t VERSION_MINOR = 240; // Last change: @_cdecl
+const uint16_t VERSION_MINOR = 241; // Last change: set_deallocating instruction
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

Diff for: lib/IRGen/GenHeap.cpp

@@ -1112,6 +1112,11 @@ void IRGenFunction::emitNativeStrongRelease(llvm::Value *value) {
   emitUnaryRefCountCall(*this, IGM.getNativeStrongReleaseFn(), value);
 }
 
+void IRGenFunction::emitNativeSetDeallocating(llvm::Value *value) {
+  if (doesNotRequireRefCounting(value)) return;
+  emitUnaryRefCountCall(*this, IGM.getNativeSetDeallocatingFn(), value);
+}
+
 void IRGenFunction::emitNativeUnownedInit(llvm::Value *value,
                                           Address dest) {
   dest = Builder.CreateStructGEP(dest, 0, Size(0));

Diff for: lib/IRGen/IRGenFunction.h

@@ -274,6 +274,7 @@ class IRGenFunction {
   void emitNativeStrongInit(llvm::Value *value, Address addr);
   void emitNativeStrongRetain(llvm::Value *value);
   void emitNativeStrongRelease(llvm::Value *value);
+  void emitNativeSetDeallocating(llvm::Value *value);
   //   - unowned references
   void emitNativeUnownedRetain(llvm::Value *value);
   void emitNativeUnownedRelease(llvm::Value *value);

Diff for: lib/IRGen/IRGenSIL.cpp

@@ -733,6 +733,7 @@ class IRGenSILFunction :
   void visitRetainValueInst(RetainValueInst *i);
   void visitReleaseValueInst(ReleaseValueInst *i);
   void visitAutoreleaseValueInst(AutoreleaseValueInst *i);
+  void visitSetDeallocatingInst(SetDeallocatingInst *i);
   void visitStructInst(StructInst *i);
   void visitTupleInst(TupleInst *i);
   void visitEnumInst(EnumInst *i);
@@ -3030,6 +3031,40 @@ void IRGenSILFunction::visitAutoreleaseValueInst(swift::AutoreleaseValueInst *i)
   emitObjCAutoreleaseCall(val);
 }
 
+void IRGenSILFunction::visitSetDeallocatingInst(SetDeallocatingInst *i) {
+  auto *ARI = dyn_cast<AllocRefInst>(i->getOperand());
+  if (ARI && StackAllocs.count(ARI)) {
+    // A small peep-hole optimization: If the operand is allocated on stack and
+    // there is no "significant" code between the set_deallocating and the final
+    // dealloc_ref, the set_deallocating is not required.
+    //   %0 = alloc_ref [stack]
+    //     ...
+    //   set_deallocating %0 // not needed
+    //     // code which does not depend on the RC_DEALLOCATING_FLAG flag.
+    //   dealloc_ref %0      // not needed (stems from the inlined deallocator)
+    //     ...
+    //   dealloc_ref [stack] %0
+    SILBasicBlock::iterator Iter(i);
+    SILBasicBlock::iterator End = i->getParent()->end();
+    for (++Iter; Iter != End; ++Iter) {
+      SILInstruction *I = &*Iter;
+      if (auto *DRI = dyn_cast<DeallocRefInst>(I)) {
+        if (DRI->getOperand() == ARI) {
+          // The set_deallocating is followed by a dealloc_ref -> we can ignore
+          // it.
+          return;
+        }
+      }
+      // Assume that any instruction with side-effects may depend on the
+      // RC_DEALLOCATING_FLAG flag.
+      if (I->mayHaveSideEffects())
+        break;
+    }
+  }
+  Explosion lowered = getLoweredExplosion(i->getOperand());
+  emitNativeSetDeallocating(lowered.claimNext());
+}
+
 void IRGenSILFunction::visitReleaseValueInst(swift::ReleaseValueInst *i) {
   Explosion in = getLoweredExplosion(i->getOperand());
   cast<LoadableTypeInfo>(getTypeInfo(i->getOperand()->getType()))

Diff for: lib/Parse/ParseSIL.cpp

@@ -1162,6 +1162,7 @@ bool SILParser::parseSILOpcode(ValueKind &Opcode, SourceLoc &OpcodeLoc,
     .Case("select_enum", ValueKind::SelectEnumInst)
     .Case("select_enum_addr", ValueKind::SelectEnumAddrInst)
     .Case("select_value", ValueKind::SelectValueInst)
+    .Case("set_deallocating", ValueKind::SetDeallocatingInst)
     .Case("store", ValueKind::StoreInst)
     .Case("store_unowned", ValueKind::StoreUnownedInst)
     .Case("store_weak", ValueKind::StoreWeakInst)
@@ -1877,6 +1878,7 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB) {
   UNARY_INSTRUCTION(IsUniqueOrPinned)
   UNARY_INSTRUCTION(DestroyAddr)
   UNARY_INSTRUCTION(AutoreleaseValue)
+  UNARY_INSTRUCTION(SetDeallocating)
   UNARY_INSTRUCTION(ReleaseValue)
   UNARY_INSTRUCTION(RetainValue)
   UNARY_INSTRUCTION(Load)

Diff for: lib/SIL/SILPrinter.cpp

@@ -1176,6 +1176,10 @@ class SILPrinter : public SILVisitor<SILPrinter> {
     *this << "autorelease_value " << getIDAndType(I->getOperand());
   }
 
+  void visitSetDeallocatingInst(SetDeallocatingInst *I) {
+    *this << "set_deallocating " << getIDAndType(I->getOperand());
+  }
+
   void visitStructInst(StructInst *SI) {
     *this << "struct " << SI->getType() << " (";
     interleave(SI->getElements(),

Diff for: lib/SIL/SILVerifier.cpp

@@ -1163,6 +1163,13 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "Source value must be a reference type or optional thereof");
   }
 
+  void checkSetDeallocatingInst(SetDeallocatingInst *I) {
+    require(I->getOperand()->getType().isObject(),
+            "Source value should be an object value");
+    require(I->getOperand()->getType().hasRetainablePointerRepresentation(),
+            "Source value must be a reference type");
+  }
+  
   void checkCopyBlockInst(CopyBlockInst *I) {
     require(I->getOperand()->getType().isBlockPointerCompatible(),
             "operand of copy_block should be a block");

Diff for: lib/SILOptimizer/Utils/SILInliner.cpp

@@ -368,6 +368,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
     case ValueKind::StoreWeakInst:
     case ValueKind::StrongPinInst:
     case ValueKind::StrongReleaseInst:
+    case ValueKind::SetDeallocatingInst:
     case ValueKind::StrongRetainInst:
     case ValueKind::StrongRetainUnownedInst:
     case ValueKind::StrongUnpinInst:

Diff for: lib/Serialization/DeserializeSIL.cpp

@@ -1171,6 +1171,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
   UNARY_INSTRUCTION(RetainValue)
   UNARY_INSTRUCTION(ReleaseValue)
   UNARY_INSTRUCTION(AutoreleaseValue)
+  UNARY_INSTRUCTION(SetDeallocating)
   UNARY_INSTRUCTION(DeinitExistentialAddr)
   UNARY_INSTRUCTION(DestroyAddr)
   UNARY_INSTRUCTION(IsNonnull)

Diff for: lib/Serialization/SerializeSIL.cpp

@@ -876,6 +876,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   case ValueKind::RetainValueInst:
   case ValueKind::ReleaseValueInst:
   case ValueKind::AutoreleaseValueInst:
+  case ValueKind::SetDeallocatingInst:
   case ValueKind::DeallocStackInst:
   case ValueKind::DeallocRefInst:
   case ValueKind::DeinitExistentialAddrInst:

Diff for: test/SIL/Parser/basic.sil

@@ -1063,6 +1063,15 @@ bb0(%0 : $X):
 // CHECK-NEXT: return [[T0]] : $X
 }
 
+// CHECK-LABEL: sil @test_set_deallocating
+sil @test_set_deallocating : $X -> X {
+bb0(%0 : $X):
+  set_deallocating %0 : $X
+  return %0 : $X
+// CHECK:      set_deallocating [[T0]] : $X
+// CHECK-NEXT: return [[T0]] : $X
+}
+
 struct GenericStruct<T> {
   var x : T
 }

Diff for: test/Serialization/Inputs/def_basic.sil

@@ -939,6 +939,15 @@ bb0(%0 : $X):
   // CHECK-NEXT: return [[T0]] : $X
 }
 
+// CHECK-LABEL: sil public_external [fragile] @test_set_deallocating
+sil [fragile] @test_set_deallocating : $@convention(thin) (X) -> (X) {
+bb0(%0 : $X):
+  set_deallocating %0 : $X
+  return %0 : $X
+  // CHECK: set_deallocating [[T0:%.*]] : $X
+  // CHECK-NEXT: return [[T0]] : $X
+}
+
 public func serialize_all() {
 }
 
@@ -1337,7 +1346,8 @@ bb0:
   %113 = function_ref @test_dynamic_lookup_br : $@convention(thin) (AnyObject) -> ()
   %115 = function_ref @test_mark_fn_escape : $@convention(thin) () -> ()
   %117 = function_ref @test_copy_release_value : $@convention(thin) (X) -> (X)
-  %118 = function_ref @cond_fail_test : $@convention(thin) Builtin.Int1 -> ()
+  %118 = function_ref @test_set_deallocating : $@convention(thin) (X) -> (X)
+  %119 = function_ref @cond_fail_test : $@convention(thin) Builtin.Int1 -> ()
 
   %124 = function_ref @block_storage_type : $@convention(thin) Int -> @convention(block) () -> ()
   %127 = function_ref @bitcasts : $@convention(thin) (@owned Class1) -> @owned (Class2, Int)
@@ -1354,7 +1364,7 @@ bb0:
   %150 = function_ref @a_reabstraction_thunk: $@convention(thin) () -> ()
   %151 = function_ref @a_regular_thunk: $@convention(thin) () -> ()
 
-  %119 = tuple ()
-  return %119 : $()
+  %r = tuple ()
+  return %r : $()
 }
 

Diff for: utils/vim/syntax/sil.vim

@@ -28,7 +28,7 @@ syn keyword swiftKeyword getter setter allocator initializer enumelt destroyer g
 syn keyword swiftKeyword alloc_global alloc_stack alloc_ref alloc_ref_dynamic alloc_box alloc_existential_box alloc_value_buffer dealloc_stack dealloc_box dealloc_existential_box dealloc_ref dealloc_partial_ref dealloc_value_buffer skipwhite
 syn keyword swiftKeyword debug_value debug_value_addr skipwhite
 syn keyword swiftKeyword load load_unowned store assign mark_uninitialized mark_function_escape copy_addr destroy_addr index_addr index_raw_pointer to skipwhite
-syn keyword swiftKeyword strong_retain strong_release strong_retain_unowned ref_to_unowned unowned_to_ref unowned_retain unowned_release load_weak store_unowned store_weak fix_lifetime autorelease_value is_unique is_unique_or_pinned strong_pin strong_unpin skipwhite
+syn keyword swiftKeyword strong_retain strong_release strong_retain_unowned ref_to_unowned unowned_to_ref unowned_retain unowned_release load_weak store_unowned store_weak fix_lifetime autorelease_value set_deallocating is_unique is_unique_or_pinned strong_pin strong_unpin skipwhite
 syn keyword swiftKeyword function_ref integer_literal float_literal string_literal global_addr skipwhite
 syn keyword swiftKeyword class_method super_method witness_method dynamic_method skipwhite
 syn keyword swiftKeyword partial_apply builtin skipwhite