Eliminate dead alloc_pack

add trivial tuple example

Author: Azoy

lib/SILOptimizer/Transforms/DeadObjectElimination.cpp

@@ -60,6 +60,9 @@ STATISTIC(DeadKeyPathEliminated,
 STATISTIC(DeadAllocApplyEliminated,
           "number of allocating Apply instructions removed");
 
+STATISTIC(DeadAllocPackEliminated,
+          "number of AllocPack instructions removed");
+
 using UserList = llvm::SmallSetVector<SILInstruction *, 16>;
 
 namespace {
@@ -283,6 +286,14 @@ static bool canZapInstruction(SILInstruction *Inst, bool acceptRefCountInsts,
   if (isa<BeginAccessInst>(Inst) || isa<EndAccessInst>(Inst))
     return true;
 
+  // Setting a value within a pack does not prevent eliminating an alloc_pack.
+  if (auto set = dyn_cast<PackElementSetInst>(Inst)) {
+    // TODO: when we have OSSA, we can also accept stores of non trivial values:
+    //       just replace the store with a destroy_value.
+    return !onlyAcceptTrivialStores ||
+           set->getElementType().isTrivial(*set->getFunction());
+  }
+
   // If Inst does not read or write to memory, have side effects, and is not a
   // terminator, we can zap it.
   if (!Inst->mayHaveSideEffects() && !Inst->mayReadFromMemory() &&
@@ -738,6 +749,7 @@ class DeadObjectElimination : public SILFunctionTransform {
   bool processKeyPath(KeyPathInst *KPI);
   bool processAllocBox(AllocBoxInst *ABI){ return false;}
   bool processAllocApply(ApplyInst *AI, DeadEndBlocks &DEBlocks);
+  bool processAllocPack(AllocPackInst *API);
 
   bool insertCompensatingReleases(SILInstruction *before,
                                   const UserList &users);
@@ -766,6 +778,8 @@ class DeadObjectElimination : public SILFunctionTransform {
           Changed |= processAllocBox(A);
         else if (auto *A = dyn_cast<ApplyInst>(&inst))
           Changed |= processAllocApply(A, DEBlocks);
+        else if (auto *A = dyn_cast<AllocPackInst>(&inst))
+          Changed |= processAllocPack(A);
       }
       deleter.cleanupDeadInstructions();
     }
@@ -899,6 +913,36 @@ bool DeadObjectElimination::processKeyPath(KeyPathInst *KPI) {
   return true;
 }
 
+bool DeadObjectElimination::processAllocPack(AllocPackInst *API) {
+  bool isTrivialType = true;
+
+  // If all the elements within this pack are trivial, then this pack is trivial.
+  // Otherwise, a single non-trivial element makes this entire pack non-trivial.
+  for (auto i : indices(API->getPackType()->getElementTypes())) {
+    auto eltTy = API->getPackType()->getSILElementType(i);
+
+    if (!eltTy.isTrivial(*API->getFunction())) {
+      isTrivialType = false;
+      break;
+    }
+  }
+
+  UserList UsersToRemove;
+  if (hasUnremovableUsers(API, &UsersToRemove, /*acceptRefCountInsts=*/ true,
+      /*onlyAcceptTrivialStores*/ !isTrivialType)) {
+    LLVM_DEBUG(llvm::dbgs() << "    Found a use that cannot be zapped...\n");
+    return false;
+  }
+
+  // Remove the AllocPack and all of its users.
+  removeInstructions(
+    ArrayRef<SILInstruction*>(UsersToRemove.begin(), UsersToRemove.end()));
+  LLVM_DEBUG(llvm::dbgs() << "    Success! Eliminating alloc_pack.\n");
+
+  ++DeadAllocPackEliminated;
+  return true;
+}
+
 /// If AI is the version of an initializer where we pass in either an apply or
 /// an alloc_ref to initialize in place, validate that we are able to continue
 /// optimizing and return To

test/SILOptimizer/dead_alloc_pack.swift

@@ -0,0 +1,58 @@
+// RUN: %target-swift-frontend -parse-as-library -O -emit-sil -enable-builtin-module -module-name dap %s | %FileCheck %s
+
+import Builtin
+
+class TrivialDestructor {
+  var int : Int
+  var int2 : Int
+  init() {
+    self.int = 0
+    self.int2 = 1
+  }
+  //deinit {}
+}
+
+class Kl {}
+
+class NontrivialDestructor {
+  var p : Kl 
+  var i : Int 
+  init() {
+    self.p = Kl()
+    self.i = 123
+  }
+}
+
+public func makeTuple<each T>(_ t: repeat each T) -> (repeat each T) {
+  (repeat each t)
+}
+
+// CHECK-LABEL: sil @$s3dap14makeEmptyTupleyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK-NEXT: [[RET:%.*]] = tuple ()
+// CHECK-NEXT: return [[RET]] : $()
+public func makeEmptyTuple() {
+  makeTuple()
+}
+
+// CHECK-LABEL: sil @$s3dap16makeTrivialTupleyyF : $@convention(thin) () -> () {
+// CHECK: bb0
+// CHECK-NEXT: [[RET:%.*]] = tuple ()
+// CHECK-NEXT: return [[RET]] : $()
+public func makeTrivialTuple() {
+  makeTuple(123, 321, 456, 654)
+}
+
+// CHECK-LABEL: sil @$s3dap26makeTrivialDestructorTupleyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK-NEXT: %0 = alloc_pack $Pack{TrivialDestructor, TrivialDestructor}
+public func makeTrivialDestructorTuple() {
+  makeTuple(TrivialDestructor(), TrivialDestructor())
+}
+
+// CHECK-LABEL: sil @$s3dap19makeNonTrivialTupleyyF : $@convention(thin) () -> () {
+// CHECK: bb0:
+// CHECK-NEXT: %0 = alloc_pack $Pack{NontrivialDestructor, NontrivialDestructor}
+public func makeNonTrivialTuple() {
+  makeTuple(NontrivialDestructor(), NontrivialDestructor())
+}

test/SILOptimizer/tuples_from_packs.swift

@@ -4,14 +4,8 @@
   return (repeat each t)
 }
 
-// FIXME: Useless alloc_pack/dealloc_pack
-
 // CHECK-LABEL: sil @$s17tuples_from_packs14makeEmptyTupleyyF : $@convention(thin) () -> () {
 // CHECK: bb0:
-// CHECK-NEXT: %0 = alloc_pack $Pack{}
-// CHECK-NEXT: %1 = alloc_pack $Pack{}
-// CHECK-NEXT: dealloc_pack %1 : $*Pack{}
-// CHECK-NEXT: dealloc_pack %0 : $*Pack{}
 // CHECK-NEXT: [[RET:%.*]] = tuple ()
 // CHECK-NEXT: return [[RET]] : $()
 public func makeEmptyTuple() {