Optimize array.getContiguousArrayStorageType calls

Author: aschwaighofer

include/swift/AST/SemanticAttrs.def

@@ -63,6 +63,7 @@ SEMANTICS_ATTR(ARRAY_COUNT, "array.count")
 SEMANTICS_ATTR(ARRAY_DEALLOC_UNINITIALIZED, "array.dealloc_uninitialized")
 SEMANTICS_ATTR(ARRAY_UNINITIALIZED_INTRINSIC, "array.uninitialized_intrinsic")
 SEMANTICS_ATTR(ARRAY_FINALIZE_INTRINSIC, "array.finalize_intrinsic")
+SEMANTICS_ATTR(ARRAY_GET_CONTIGUOUSARRAYSTORAGETYPE, "array.getContiguousArrayStorageType")
 
 SEMANTICS_ATTR(SEQUENCE_FOR_EACH, "sequence.forEach")
 SEMANTICS_ATTR(TYPENAME, "typeName")

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -1571,6 +1571,40 @@ bool SILCombiner::optimizeIdentityCastComposition(ApplyInst *fInverseApply,
   return true;
 }
 
+/// Should replace a call to `getContiguousArrayStorageType<A>(for:)` by the
+/// metadata constructor.
+/// We know that `getContiguousArrayStorageType` will not return the AnyObject
+/// type optimization for any non class or objc existential type instantiation.
+static bool shouldReplaceCallByMetadataConstructor(CanType storageMetaTy) {
+  auto metaTy = dyn_cast<MetatypeType>(storageMetaTy);
+  if (!metaTy || metaTy->getRepresentation() != MetatypeRepresentation::Thick)
+    return false;
+
+  auto storageTy = metaTy.getInstanceType()->getCanonicalType();
+  if (!storageTy->is_ContiguousArrayStorage())
+    return false;
+
+  auto boundGenericTy = dyn_cast<BoundGenericType>(storageTy);
+  if (!boundGenericTy)
+    return false;
+
+  for (auto TP : boundGenericTy->getGenericArgs()) {
+    auto ty = TP->getCanonicalType();
+    if (ty->getStructOrBoundGenericStruct() ||
+        ty->getEnumOrBoundGenericEnum() ||
+        isa<BuiltinVectorType>(ty) ||
+        isa<BuiltinIntegerType>(ty) ||
+        isa<BuiltinFloatType>(ty) ||
+        isa<TupleType>(ty) ||
+        isa<AnyFunctionType>(ty) ||
+        (ty->isAnyExistentialType() && !ty->isObjCExistentialType()))
+      return true;
+
+    return false;
+  }
+  return false;
+}
+
 SILInstruction *SILCombiner::visitApplyInst(ApplyInst *AI) {
   Builder.setCurrentDebugScope(AI->getDebugScope());
   // apply{partial_apply(x,y)}(z) -> apply(z,x,y) is triggered
@@ -1604,6 +1638,16 @@ SILInstruction *SILCombiner::visitApplyInst(ApplyInst *AI) {
           return nullptr;
       }
     }
+    if (SF->hasSemanticsAttr(semantics::ARRAY_GET_CONTIGUOUSARRAYSTORAGETYPE)) {
+      auto silTy = AI->getType();
+      auto storageTy = AI->getType().getASTType();
+      if (shouldReplaceCallByMetadataConstructor(storageTy)) {
+        auto metatype = Builder.createMetatype(AI->getLoc(), silTy);
+        AI->replaceAllUsesWith(metatype);
+        eraseInstFromFunction(*AI);
+        return nullptr;
+      }
+    }
   }
 
 

test/SILOptimizer/stack_promotion_2_modules.swift

@@ -64,7 +64,7 @@ import Module
 // Check if the array literal can be stack promoted.
 
 // CHECK-LABEL: sil @$s4main6testit6Module3FooVyF
-// CHECK:   alloc_ref_dynamic [stack] [tail_elems $Foo.FooElement
+// CHECK:   alloc_ref{{.*}} [stack] [tail_elems $Foo.FooElement
 // CHECK: } // end sil function '$s4main6testit6Module3FooVyF'
 
 public func testit() -> Foo {

test/SILOptimizer/stack_promotion_array_literal.swift

@@ -5,7 +5,7 @@
 // stack promoted.
 
 // CHECK-LABEL: sil @{{.*}}testit
-// CHECK:  alloc_ref_dynamic [stack] [tail_elems
+// CHECK:  alloc_ref{{.*}} [stack] [tail_elems
 
 public func testit(_ N: Int, _ x: Int) {
   for _ in 0..<N {