SILOptimizer: only do SROA when it has a benefit.

Replacing an alloc_stack of a struct/tuple with multiple alloc_stacks of the struct/tuple elements should only be done if the elements are somehow accessed individually.
If not, e.g. if the whole struct/tuple is just copied, there is no benefit of doing SROA.

Although this change has little impact by its own (some small code size wins), it is important for the improvement of let-property optimization.

Author: eeckstein

lib/SILOptimizer/Transforms/SILSROA.cpp

@@ -138,6 +138,8 @@ bool SROAMemoryUseAnalyzer::analyze() {
     return false;
   }
 
+  bool hasBenefit = false;
+
   // Go through uses of the memory allocation of AI...
   for (auto *Operand : getNonDebugUses(SILValue(AI))) {
     SILInstruction *User = Operand->getUser();
@@ -150,6 +152,9 @@ bool SROAMemoryUseAnalyzer::analyze() {
         LLVM_DEBUG(llvm::dbgs() << "        Found a store into the "
                                    "projection.\n");
         Stores.push_back(SI);
+        SILValue Src = SI->getSrc();
+        if (isa<StructInst>(Src) || isa<TupleInst>(Src))
+          hasBenefit = true;
         continue;
       } else {
         LLVM_DEBUG(llvm::dbgs() << "        Found a store of the "
@@ -163,6 +168,11 @@ bool SROAMemoryUseAnalyzer::analyze() {
     if (auto *LI = dyn_cast<LoadInst>(User)) {
       LLVM_DEBUG(llvm::dbgs() << "        Found a load of the projection.\n");
       Loads.push_back(LI);
+      for (auto useIter = LI->use_begin(), End = LI->use_end();
+           !hasBenefit && useIter != End; useIter++) {
+        hasBenefit = (isa<StructExtractInst>(useIter->get()) ||
+                      isa<TupleExtractInst>(useIter->get()));
+      }
       continue;
     }
 
@@ -171,6 +181,7 @@ bool SROAMemoryUseAnalyzer::analyze() {
     if (auto *ASI = dyn_cast<StructElementAddrInst>(User)) {
       LLVM_DEBUG(llvm::dbgs() << "        Found a struct subprojection!\n");
       ExtractInsts.push_back(ASI);
+      hasBenefit = true;
       continue;
     }
 
@@ -179,6 +190,7 @@ bool SROAMemoryUseAnalyzer::analyze() {
     if (auto *TSI = dyn_cast<TupleElementAddrInst>(User)) {
       LLVM_DEBUG(llvm::dbgs() << "        Found a tuple subprojection!\n");
       ExtractInsts.push_back(TSI);
+      hasBenefit = true;
       continue;
     }
 
@@ -195,7 +207,7 @@ bool SROAMemoryUseAnalyzer::analyze() {
 
   // Analysis was successful. We can break up this allocation!
   ++NumChoppedAllocas;
-  return true;
+  return hasBenefit;
 }
 
 void

test/SILOptimizer/optionset.swift

@@ -16,6 +16,7 @@ public struct TestOptions: OptionSet {
 // CHECK-NEXT: bb0:
 // CHECK-NEXT:   integer_literal {{.*}}, 15
 // CHECK-NEXT:   struct $Int
+// CHECK-NEXT:   debug_value
 // CHECK-NEXT:   struct $TestOptions
 // CHECK-NEXT:   return
 public func returnTestOptions() -> TestOptions {
@@ -26,6 +27,7 @@ public func returnTestOptions() -> TestOptions {
 // CHECK-NEXT:   global_addr
 // CHECK-NEXT:   integer_literal {{.*}}, 15
 // CHECK-NEXT:   struct $Int
+// CHECK-NEXT:   debug_value
 // CHECK-NEXT:   struct $TestOptions
 // CHECK-NEXT:   store
 // CHECK-NEXT:   tuple

test/SILOptimizer/specialize_unconditional_checked_cast.swift

@@ -100,6 +100,7 @@ ArchetypeToConcreteConvertUInt8(t: f)
 // CHECK-LABEL: sil shared [noinline] @$S37specialize_unconditional_checked_cast31ArchetypeToConcreteConvertUInt8{{[_0-9a-zA-Z]*}}3Not{{.*}}Tg5 : $@convention(thin) (NotUInt8) -> NotUInt8 {
 // CHECK: bb0
 // CHECK-NEXT: debug_value %0
+// CHECK-NEXT: debug_value %0
 // CHECK-NEXT: return %0
 
 // x -> y where y is a class but x is not.

test/SILOptimizer/sroa.sil

@@ -56,6 +56,23 @@ bb0(%0 : $S1):
   return %6 : $()
 }
 
+// CHECK-LABEL: sil @dont_sroa_without_benefit : $@convention(thin) (S1) -> S1
+// CHECK:      bb0
+// CHECK-NEXT:   alloc_stack $S1
+// CHECK-NEXT:   store %0 to %1 : $*S1
+// CHECK-NEXT:   load %1 : $*S1
+// CHECK-NEXT:   dealloc_stack %1 : $*S1
+// CHECK-NEXT:   return
+sil @dont_sroa_without_benefit : $@convention(thin) (S1) -> S1 {
+bb0(%0 : $S1):
+  %1 = alloc_stack $S1
+  store %0 to %1 : $*S1
+  %3 = load %1 : $*S1
+  dealloc_stack %1 : $*S1
+  return %3 : $S1
+}
+
+
 ///////////////////////////////
 // Struct With Struct Fields //
 ///////////////////////////////