Merge pull request #1696 from eeckstein/fix_release_devirtualizer

Fix release devirtualizer

Author: eeckstein

docs/Runtime.md

@@ -160,6 +160,7 @@ Returns a random number. Only used by allocation profiling tools.
 000000000002b290 T _swift_isUniquelyReferencedOrPinned_nonNull_native
 000000000002af00 T _swift_isUniquelyReferenced_native
 000000000002aea0 T _swift_isUniquelyReferenced_nonNull_native
+00000000000????? T _swift_setDeallocating
 000000000001d280 T _swift_isDeallocating
 ```
 

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

include/swift/Runtime/HeapObject.h

@@ -292,6 +292,12 @@ SWIFT_RUNTIME_EXPORT
 extern "C" void (*SWIFT_CC(RegisterPreservingCC)
                      _swift_release_n)(HeapObject *object, uint32_t n);
 
+/// Sets the RC_DEALLOCATING_FLAG flag. This is done non-atomically.
+/// The strong reference count of \p object must be 1 and no other thread may
+/// retain the object during executing this function.
+SWIFT_RUNTIME_EXPORT
+extern "C" void swift_setDeallocating(HeapObject *object);
+
 // Refcounting observation hooks for memory tools. Don't use these.
 SWIFT_RUNTIME_EXPORT
 extern "C" size_t swift_retainCount(HeapObject *object);

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,

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(

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) {

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

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)

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>;

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));