[SILOptimizer] Do not hardcode unowned for loadable ref storage types

Author: davezarzycki

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -781,10 +781,13 @@ SILInstruction *SILCombiner::visitReleaseValueInst(ReleaseValueInst *RVI) {
     }
   }
 
-  // ReleaseValueInst of an unowned type is an unowned_release.
-  if (OperandTy.is<UnownedStorageType>())
-    return Builder.createUnownedRelease(RVI->getLoc(), Operand,
+  // ReleaseValueInst of a loadable reference storage type needs the
+  // corresponding release instruction.
+#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
+  if (OperandTy.is<Name##StorageType>())                                       \
+    return Builder.create##Name##Release(RVI->getLoc(), Operand,               \
                                         RVI->getAtomicity());
+#include "swift/AST/ReferenceStorage.def"
 
   // ReleaseValueInst of a reference type is a strong_release.
   if (OperandTy.isReferenceCounted(RVI->getModule()))
@@ -821,10 +824,13 @@ SILInstruction *SILCombiner::visitRetainValueInst(RetainValueInst *RVI) {
     }
   }
 
-  // RetainValueInst of an unowned type is an unowned_retain.
-  if (OperandTy.is<UnownedStorageType>())
-    return Builder.createUnownedRetain(RVI->getLoc(), Operand,
+  // RetainValueInst of a loadable reference storage type needs the
+  // corresponding retain instruction.
+#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
+  if (OperandTy.is<Name##StorageType>())                                       \
+    return Builder.create##Name##Retain(RVI->getLoc(), Operand,                \
                                        RVI->getAtomicity());
+#include "swift/AST/ReferenceStorage.def"
 
   // RetainValueInst of a reference type is a strong_release.
   if (OperandTy.isReferenceCounted(RVI->getModule())) {

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -58,12 +58,14 @@ swift::createIncrementBefore(SILValue ptr, SILInstruction *insertPt) {
   // If Ptr is refcounted itself, create the strong_retain and
   // return.
   if (ptr->getType().isReferenceCounted(builder.getModule())) {
-    if (ptr->getType().is<UnownedStorageType>())
-      return builder.createUnownedRetain(loc, ptr,
-                                         builder.getDefaultAtomicity());
-    else
-      return builder.createStrongRetain(loc, ptr,
-                                        builder.getDefaultAtomicity());
+#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
+    if (ptr->getType().is<Name##StorageType>())                                \
+      return builder.create##Name##Retain(loc, ptr,                            \
+                                          builder.getDefaultAtomicity());
+#include "swift/AST/ReferenceStorage.def"
+
+    return builder.createStrongRetain(loc, ptr,
+                                      builder.getDefaultAtomicity());
   }
 
   // Otherwise, create the retain_value.
@@ -85,12 +87,14 @@ swift::createDecrementBefore(SILValue ptr, SILInstruction *insertPt) {
 
   // If ptr has reference semantics itself, create a strong_release.
   if (ptr->getType().isReferenceCounted(builder.getModule())) {
-    if (ptr->getType().is<UnownedStorageType>())
-      return builder.createUnownedRelease(loc, ptr,
+#define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
+    if (ptr->getType().is<Name##StorageType>())                                \
+      return builder.create##Name##Release(loc, ptr,                           \
                                           builder.getDefaultAtomicity());
-    else
-      return builder.createStrongRelease(loc, ptr,
-                                         builder.getDefaultAtomicity());
+#include "swift/AST/ReferenceStorage.def"
+
+    return builder.createStrongRelease(loc, ptr,
+                                       builder.getDefaultAtomicity());
   }
 
   // Otherwise create a release value.