Swift Optimizer: eliminate ARC operations on types which are marked as immortal

A type (mostly classes) can be attributed with `@_semantics("arc.immortal")`.
ARC operations on values of such types are eliminated.

This is useful for the bridged SIL objects in the swift compiler sources.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyStrongRetainRelease.swift

@@ -67,6 +67,9 @@ extension StrongReleaseInst : Simplifyable, SILCombineSimplifyable {
 /// Returns true if \p value is something where reference counting instructions
 /// don't have any effect.
 private func isNotReferenceCounted(value: Value) -> Bool {
+  if value.type.isMarkedAsImmortal {
+    return true
+  }
   switch value {
     case let cfi as ConvertFunctionInst:
       return isNotReferenceCounted(value: cfi.fromFunction)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -58,7 +58,9 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   }
 
   public var isCalleeConsumedFunction: Bool { SILType_isCalleeConsumedFunction(bridged) }
-  
+
+  public var isMarkedAsImmortal: Bool { SILType_isMarkedAsImmortal(bridged) }
+
   public func getIndexOfEnumCase(withName name: String) -> Int? {
     let idx = name._withStringRef {
       SILType_getCaseIdxOfEnumType(bridged, $0)

include/swift/AST/SemanticAttrs.def

@@ -76,6 +76,13 @@ SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_GENERIC_SIZE_NEVER,
 SEMANTICS_ATTR(OPTIMIZE_SIL_SPECIALIZE_OWNED2GUARANTEE_NEVER,
           "optimize.sil.specialize.owned2guarantee.never")
 
+// To be used on a nominal type declaration.
+// Assumes that a class (or class references inside a nominal type) are immortal.
+// ARC operations on such types can be eliminated.
+// If specified on a protocol declaration, all types which conform to that protocol
+// are assumed to be immortal.
+SEMANTICS_ATTR(ARC_IMMORTAL, "arc.immortal")
+
 SEMANTICS_ATTR(OSLOG_MESSAGE_TYPE, "oslog.message.type")
 SEMANTICS_ATTR(OSLOG_MESSAGE_INIT_INTERPOLATION, "oslog.message.init_interpolation")
 SEMANTICS_ATTR(OSLOG_MESSAGE_INIT_STRING_LITERAL, "oslog.message.init_stringliteral")

include/swift/SIL/SILBridging.h

@@ -345,6 +345,7 @@ BridgedType SILType_instanceTypeOfMetatype(BridgedType type, BridgedFunction fun
 BridgedDecl SILType_getNominal(BridgedType type);
 bool SILType_isOrContainsObjectiveCClass(BridgedType type);
 bool SILType_isCalleeConsumedFunction(BridgedType type);
+bool SILType_isMarkedAsImmortal(BridgedType type);
 SwiftInt SILType_getNumTupleElements(BridgedType type);
 BridgedType SILType_getTupleElementType(BridgedType type, SwiftInt elementIdx);
 SwiftInt SILType_getNumNominalFields(BridgedType type);

lib/SIL/Utils/SILBridging.cpp

@@ -11,6 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Basic/BridgingUtils.h"
+#include "swift/AST/Attr.h"
+#include "swift/AST/SemanticAttrs.h"
 #include "swift/SIL/SILNode.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/SILBridgingUtils.h"
@@ -587,6 +589,48 @@ bool SILType_isCalleeConsumedFunction(BridgedType type) {
   return funcTy->isCalleeConsumed() && !funcTy->isNoEscape();
 }
 
+static bool hasImmortalAttr(NominalTypeDecl *nominal) {
+  if (auto *semAttr = nominal->getAttrs().getAttribute<SemanticsAttr>()) {
+    if (semAttr->Value == semantics::ARC_IMMORTAL) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static bool isMarkedAsImmortal(NominalTypeDecl *nominal) {
+  if (hasImmortalAttr(nominal))
+    return true;
+
+  if (!isa<ProtocolDecl>(nominal)) {
+    for (ProtocolDecl *p : nominal->getAllProtocols()) {
+      if (hasImmortalAttr(p))
+        return true;
+    }
+  }
+  return false;
+}
+
+bool SILType_isMarkedAsImmortal(BridgedType type) {
+  SILType ty = castToSILType(type);
+  NominalTypeDecl *nominal = ty.getNominalOrBoundGenericNominal();
+  if (!nominal)
+    return false;
+
+  if (isMarkedAsImmortal(nominal))
+    return true;
+
+  if (ClassDecl *cl = dyn_cast<ClassDecl>(nominal)) {
+    cl = cl->getSuperclassDecl();
+    while (cl) {
+      if (isMarkedAsImmortal(cl))
+        return true;
+      cl = cl->getSuperclassDecl();
+    }
+  }
+  return false;
+}
+
 SwiftInt SILType_getNumTupleElements(BridgedType type) {
   TupleType *tupleTy = castToSILType(type).castTo<TupleType>();
   return tupleTy->getNumElements();

test/SILOptimizer/immortal-arc-elimination.sil

@@ -61,3 +61,55 @@ bb0:
   return %1 : $Builtin.BridgeObject
 }
 
+@_semantics("arc.immortal") protocol P : AnyObject {
+}
+
+@_semantics("arc.immortal") class C {
+  init()
+}
+
+@_inheritsConvenienceInitializers class D : C {
+  override init()
+}
+
+class E : P {
+  init()
+}
+
+// CHECK-LABEL: sil @testSemanticsOnClass
+// CHECK-NOT:   retain
+// CHECK: } // end sil function 'testSemanticsOnClass'
+sil @testSemanticsOnClass : $@convention(thin) (@guaranteed C) -> @owned C {
+bb0(%0 : $C):
+  strong_retain %0 : $C
+  return %0 : $C                                  // id: %3
+}
+
+// CHECK-LABEL: sil @testSemanticsOnDerivedClass
+// CHECK-NOT:   retain
+// CHECK: } // end sil function 'testSemanticsOnDerivedClass'
+sil @testSemanticsOnDerivedClass : $@convention(thin) (@guaranteed D) -> @owned D {
+bb0(%0 : $D):
+  strong_retain %0 : $D
+  return %0 : $D
+}
+
+// CHECK-LABEL: sil @testSemanticsOnConformingClass
+// CHECK-NOT:   retain
+// CHECK: } // end sil function 'testSemanticsOnConformingClass'
+sil @testSemanticsOnConformingClass : $@convention(thin) (@guaranteed E) -> @owned E {
+bb0(%0 : $E):
+  strong_retain %0 : $E
+  return %0 : $E
+}
+
+// CHECK-LABEL: sil @testSemanticsOnProtocol
+// CHECK-NOT:   retain
+// CHECK: } // end sil function 'testSemanticsOnProtocol'
+sil @testSemanticsOnProtocol : $@convention(thin) (@guaranteed any P) -> @owned any P {
+bb0(%0 : $any P):
+  strong_retain %0 : $any P
+  return %0 : $any P
+}
+
+