Revert "Merge pull request #25038 from atrick/fix-specializer-leak"

This reverts commit d402077, reversing
changes made to 651045f.

Author: dan-zheng

include/swift/AST/SILOptions.h

@@ -50,6 +50,9 @@ class SILOptions {
   /// Remove all runtime assertions during optimizations.
   bool RemoveRuntimeAsserts = false;
 
+  /// Enable existential specializer optimization.
+  bool ExistentialSpecializer = false;
+
   /// Controls whether the SIL ARC optimizations are run.
   bool EnableARCOptimizations = true;
 

include/swift/Option/FrontendOptions.td

@@ -472,6 +472,9 @@ def sil_unroll_threshold : Separate<["-"], "sil-unroll-threshold">,
   MetaVarName<"<250>">,
   HelpText<"Controls the aggressiveness of loop unrolling">;
 
+def sil_existential_specializer : Flag<["-"], "sil-existential-specializer">,
+  HelpText<"Enable SIL existential specializer optimization">;
+
 def sil_merge_partial_modules : Flag<["-"], "sil-merge-partial-modules">,
   HelpText<"Merge SIL from all partial swiftmodules into the final module">;
 

lib/Frontend/CompilerInvocation.cpp

@@ -703,6 +703,9 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
       return true;
     }
   }
+  if (Args.hasArg(OPT_sil_existential_specializer)) {
+    Opts.ExistentialSpecializer = true;
+  }
   if (const Arg *A = Args.getLastArg(OPT_num_threads)) {
     if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) {
       Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,

lib/SILOptimizer/FunctionSignatureTransforms/ExistentialSpecializer.cpp

@@ -28,11 +28,6 @@
 
 using namespace swift;
 
-static llvm::cl::opt<bool>
-EnableExistentialSpecializer("enable-existential-specializer",
-                             llvm::cl::Hidden,
-                             llvm::cl::init(true));
-
 STATISTIC(NumFunctionsWithExistentialArgsSpecialized,
           "Number of functions with existential args specialized");
 
@@ -71,7 +66,7 @@ class ExistentialSpecializer : public SILFunctionTransform {
     auto *F = getFunction();
 
     /// Don't optimize functions that should not be optimized.
-    if (!F->shouldOptimize() || !EnableExistentialSpecializer) {
+    if (!F->shouldOptimize() || !F->getModule().getOptions().ExistentialSpecializer) {
       return;
     }
 
@@ -115,6 +110,19 @@ bool ExistentialSpecializer::findConcreteTypeFromSoleConformingType(
   return true;
 }
 
+/// Check if the argument Arg is used in a destroy_use instruction.
+static void
+findIfCalleeUsesArgInDestroyUse(SILValue Arg,
+                                ExistentialTransformArgumentDescriptor &ETAD) {
+  for (Operand *ArgUse : Arg->getUses()) {
+    auto *ArgUser = ArgUse->getUser();
+    if (isa<DestroyAddrInst>(ArgUser)) {
+      ETAD.DestroyAddrUse = true;
+      break;
+    }
+  }
+}
+
 /// Helper function to ensure that the argument is not InOut or InOut_Aliasable
 static bool isNonInoutIndirectArgument(SILValue Arg,
                                        SILArgumentConvention ArgConvention) {
@@ -180,27 +188,24 @@ bool ExistentialSpecializer::canSpecializeExistentialArgsInFunction(
       continue;
     }
 
-    /// Determine attributes of the existential addr argument.
+    /// Determine attributes of the existential addr arguments such as
+    /// destroy_use, immutable_access. 
     ExistentialTransformArgumentDescriptor ETAD;
     auto paramInfo = origCalleeConv.getParamInfoForSILArg(Idx);
-    // The ExistentialSpecializerCloner copies the incoming generic argument
-    // into an existential. This won't work if the original argument is
-    // mutated. Furthermore, SILCombine would not be able to replace a mutated
-    // existential with a concrete value, so the specialization thunk could not
-    // be optimized away.
-    if (paramInfo.isIndirectMutating())
-      continue;
-
-    ETAD.AccessType = paramInfo.isConsumed()
+    ETAD.AccessType = (paramInfo.isIndirectMutating() || paramInfo.isConsumed())
                           ? OpenedExistentialAccess::Mutable
                           : OpenedExistentialAccess::Immutable;
-    ETAD.isConsumed = paramInfo.isConsumed();
+    ETAD.DestroyAddrUse = false;
+    if ((CalleeArgs[Idx]->getType().getPreferredExistentialRepresentation(
+            F->getModule()))
+        != ExistentialRepresentation::Class)
+      findIfCalleeUsesArgInDestroyUse(CalleeArg, ETAD);
 
     /// Save the attributes
     ExistentialArgDescriptor[Idx] = ETAD;
     LLVM_DEBUG(llvm::dbgs()
                << "ExistentialSpecializer Pass:Function: " << F->getName()
-               << " Arg:" << Idx << " has a concrete type.\n");
+               << " Arg:" << Idx << "has a concrete type.\n");
     returnFlag |= true;
   }
   return returnFlag;