Merge pull request #40189 from gottesmm/pr-aeffd0309402b8c9a744770c71ce40ca6f0459ff

gottesmm · web-flow · commit 3eba144b83ba · 2021-11-15T16:47:38.000-08:00
[move-operator] Specify if LexicalLifetimes is enabled using an enum instead of a bool.
diff --git a/include/swift/AST/SILOptions.h b/include/swift/AST/SILOptions.h
@@ -30,6 +30,17 @@
 
 namespace swift {
 
+enum class LexicalLifetimesOption : uint8_t {
+  // Do not insert any lexical lifetimes.
+  Off = 0,
+
+  // Insert lexical lifetimes and do not remove them until OSSA is lowered. This
+  // is experimental.
+  ExperimentalLate,
+};
+
+class SILModule;
+
 class SILOptions {
 public:
   /// Controls the aggressiveness of the performance inliner.
@@ -45,7 +56,7 @@ class SILOptions {
   bool RemoveRuntimeAsserts = false;
 
   /// Enable experimental support for emitting defined borrow scopes.
-  bool EnableExperimentalLexicalLifetimes = false;
+  LexicalLifetimesOption LexicalLifetimes = LexicalLifetimesOption::Off;
 
   /// Force-run SIL copy propagation to shorten object lifetime in whatever
   /// optimization pipeline is currently used.
@@ -226,6 +237,12 @@ class SILOptions {
   bool shouldOptimize() const {
     return OptMode > OptimizationMode::NoOptimization;
   }
+
+  /// Returns true if we support inserting lexical lifetimes given the current
+  /// SIL stage.
+  ///
+  /// Defined in SILModule.h.
+  bool supportsLexicalLifetimes(const SILModule &mod) const;
 };
 
 } // end namespace swift
diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
@@ -255,9 +255,15 @@ def enable_experimental_concurrency :
   Flag<["-"], "enable-experimental-concurrency">,
   HelpText<"Enable experimental concurrency model">;
 
+def disable_lexical_lifetimes :
+  Flag<["-"], "disable-lexical-lifetimes">,
+  HelpText<"Disables early lexical lifetimes. Mutually exclusive with "
+           "-enable-experimental-lexical-lifetimes">;
+
 def enable_experimental_lexical_lifetimes :
   Flag<["-"], "enable-experimental-lexical-lifetimes">,
-  HelpText<"Enable experimental lexical lifetimes">;
+  HelpText<"Enable experimental lexical lifetimes. Mutually exclusive with "
+           "-disable-early-lexical-lifetimes">;
 
 def enable_experimental_move_only :
   Flag<["-"], "enable-experimental-move-only">,
diff --git a/include/swift/SIL/SILModule.h b/include/swift/SIL/SILModule.h
@@ -908,6 +908,22 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SILModule &M){
   return OS;
 }
 
+inline bool SILOptions::supportsLexicalLifetimes(const SILModule &mod) const {
+  switch (mod.getStage()) {
+  case SILStage::Raw:
+    // In Raw SIL, we support lexical lifetimes as long as lexical lifetimes is
+    // not turned off all the way.
+    return LexicalLifetimes != LexicalLifetimesOption::Off;
+  case SILStage::Canonical:
+    // In Canonical SIL, we only support lexical lifetimes when in experimental
+    // late mode.
+    return LexicalLifetimes == LexicalLifetimesOption::ExperimentalLate;
+  case SILStage::Lowered:
+    // We do not support OSSA in Lowered SIL, so this is always false.
+    return false;
+  }
+}
+
 /// Print a simple description of a SILModule for the request evaluator.
 void simple_display(llvm::raw_ostream &out, const SILModule *M);
 
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/SILOptions.h"
 #include "swift/Frontend/Frontend.h"
 
 #include "ArgsToFrontendOptionsConverter.h"
@@ -1430,12 +1431,22 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   // -Ounchecked might also set removal of runtime asserts (cond_fail).
   Opts.RemoveRuntimeAsserts |= Args.hasArg(OPT_RemoveRuntimeAsserts);
 
-  Opts.EnableExperimentalLexicalLifetimes |=
-      Args.hasArg(OPT_enable_experimental_lexical_lifetimes);
   // If experimental move only is enabled, always enable lexical lifetime as
   // well. Move only depends on lexical lifetimes.
-  Opts.EnableExperimentalLexicalLifetimes |=
+  bool enableExperimentalLexicalLifetimes =
+      Args.hasArg(OPT_enable_experimental_lexical_lifetimes) ||
       Args.hasArg(OPT_enable_experimental_move_only);
+  // Error if both experimental lexical lifetimes and disable lexical lifetimes
+  // are both set.
+  if (enableExperimentalLexicalLifetimes &&
+      Args.hasArg(OPT_disable_lexical_lifetimes)) {
+    return true;
+  } else {
+    if (enableExperimentalLexicalLifetimes)
+      Opts.LexicalLifetimes = LexicalLifetimesOption::ExperimentalLate;
+    if (Args.hasArg(OPT_disable_lexical_lifetimes))
+      Opts.LexicalLifetimes = LexicalLifetimesOption::Off;
+  }
 
   Opts.EnableCopyPropagation |= Args.hasArg(OPT_enable_copy_propagation);
   Opts.DisableCopyPropagation |= Args.hasArg(OPT_disable_copy_propagation);
diff --git a/lib/SILGen/SILGenDecl.cpp b/lib/SILGen/SILGenDecl.cpp
@@ -540,7 +540,7 @@ class LetValueInitialization : public Initialization {
       address = value;
     SILLocation PrologueLoc(vd);
 
-    if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
+    if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule()) &&
         value->getOwnershipKind() != OwnershipKind::None) {
       if (!SGF.getASTContext().LangOpts.EnableExperimentalMoveOnly) {
         value = SILValue(
@@ -1760,7 +1760,7 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
     return;
   }
 
-  if (!getASTContext().SILOpts.EnableExperimentalLexicalLifetimes ||
+  if (!getASTContext().SILOpts.supportsLexicalLifetimes(getModule()) ||
       Val->getOwnershipKind() == OwnershipKind::None) {
     B.emitDestroyValueOperation(silLoc, Val);
     return;
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -273,7 +273,8 @@ struct ArgumentInitHelper {
     SILValue value = argrv.getValue();
     SILDebugVariable varinfo(pd->isImmutable(), ArgNo);
     if (!argrv.getType().isAddress()) {
-      if (SGF.getASTContext().SILOpts.EnableExperimentalLexicalLifetimes &&
+      if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(
+              SGF.getModule()) &&
           value->getOwnershipKind() == OwnershipKind::Owned) {
         bool isNoImplicitCopy = false;
         if (auto *arg = dyn_cast<SILFunctionArgument>(value))
diff --git a/lib/SILOptimizer/Mandatory/LexicalLifetimeEliminator.cpp b/lib/SILOptimizer/Mandatory/LexicalLifetimeEliminator.cpp
@@ -26,9 +26,11 @@ class LexicalLifetimeEliminatorPass : public SILFunctionTransform {
     if (fn->wasDeserializedCanonical())
       return;
 
-    // If we have experimental lexical lifetimes enabled, we do not want to run
-    // this pass since we want lexical lifetimes to exist later in the pipeline.
-    if (fn->getModule().getOptions().EnableExperimentalLexicalLifetimes)
+    // If we have experimental late lexical lifetimes enabled, we do not want to
+    // run this pass since we want lexical lifetimes to exist later in the
+    // pipeline.
+    if (fn->getModule().getOptions().LexicalLifetimes ==
+        LexicalLifetimesOption::ExperimentalLate)
       return;
 
     bool madeChange = false;
diff --git a/lib/SILOptimizer/PassManager/PassPipeline.cpp b/lib/SILOptimizer/PassManager/PassPipeline.cpp
@@ -19,6 +19,7 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "swift/AST/SILOptions.h"
 #define DEBUG_TYPE "sil-passpipeline-plan"
 #include "swift/SILOptimizer/PassManager/PassPipeline.h"
 #include "swift/AST/ASTContext.h"
@@ -138,7 +139,8 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
     P.addSILSkippingChecker();
 #endif
 
-  if (Options.shouldOptimize() && !Options.EnableExperimentalLexicalLifetimes) {
+  if (Options.shouldOptimize() &&
+      Options.LexicalLifetimes != LexicalLifetimesOption::ExperimentalLate) {
     P.addDestroyHoisting();
   }
   P.addMandatoryInlining();
@@ -171,7 +173,7 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
 
   // Now that we have finished performing diagnostics that rely on lexical
   // scopes, if lexical lifetimes are not enabled, eliminate lexical lfietimes.
-  if (!Options.EnableExperimentalLexicalLifetimes) {
+  if (Options.LexicalLifetimes != LexicalLifetimesOption::ExperimentalLate) {
     P.addLexicalLifetimeEliminator();
   }
 
diff --git a/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp b/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp
@@ -533,10 +533,8 @@ static bool rewriteAllocBoxAsAllocStack(AllocBoxInst *ABI) {
   SILBuilderWithScope Builder(ABI);
   assert(ABI->getBoxType()->getLayout()->getFields().size() == 1
          && "rewriting multi-field box not implemented");
-  bool isLexical = ABI->getFunction()
-                       ->getModule()
-                       .getASTContext()
-                       .SILOpts.EnableExperimentalLexicalLifetimes;
+  auto &mod = ABI->getFunction()->getModule();
+  bool isLexical = mod.getASTContext().SILOpts.supportsLexicalLifetimes(mod);
   auto *ASI = Builder.createAllocStack(
       ABI->getLoc(),
       getSILBoxFieldType(TypeExpansionContext(*ABI->getFunction()),
diff --git a/lib/SILOptimizer/Transforms/SILMem2Reg.cpp b/lib/SILOptimizer/Transforms/SILMem2Reg.cpp
@@ -314,9 +314,10 @@ static SILValue createValueForEmptyTuple(SILType ty,
 static bool shouldAddLexicalLifetime(AllocStackInst *asi) {
   return asi->getFunction()->hasOwnership() &&
          asi->getFunction()
-             ->getModule()
-             .getASTContext()
-             .SILOpts.EnableExperimentalLexicalLifetimes &&
+                 ->getModule()
+                 .getASTContext()
+                 .SILOpts.LexicalLifetimes ==
+             LexicalLifetimesOption::ExperimentalLate &&
          asi->isLexical() &&
          !asi->getElementType().isTrivial(*asi->getFunction());
 }
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -578,10 +578,9 @@ void SILInlineCloner::postFixUp(SILFunction *calleeFunction) {
 
 SILValue SILInlineCloner::borrowFunctionArgument(SILValue callArg,
                                                  FullApplySite AI) {
-  auto enableLexicalLifetimes = Apply.getFunction()
-                                    ->getModule()
-                                    .getASTContext()
-                                    .SILOpts.EnableExperimentalLexicalLifetimes;
+  auto &mod = Apply.getFunction()->getModule();
+  auto enableLexicalLifetimes =
+      mod.getASTContext().SILOpts.supportsLexicalLifetimes(mod);
   auto argOwnershipRequiresBorrow = [&]() {
     auto kind = callArg.getOwnershipKind();
     if (enableLexicalLifetimes) {
diff --git a/tools/sil-opt/SILOpt.cpp b/tools/sil-opt/SILOpt.cpp
@@ -107,7 +107,13 @@ EnableExperimentalConcurrency("enable-experimental-concurrency",
 
 static llvm::cl::opt<bool> EnableExperimentalLexicalLifetimes(
     "enable-experimental-lexical-lifetimes",
-    llvm::cl::desc("Enable experimental lexical lifetimes."));
+    llvm::cl::desc("Enable experimental lexical lifetimes. Mutually exclusive "
+                   "with disable-lexical-lifetimes."));
+
+static llvm::cl::opt<bool> DisableLexicalLifetimes(
+    "disable-lexical-lifetimes",
+    llvm::cl::desc("Disable the default early lexical lifetimes. Mutually "
+                   "exclusive with enable-experimental-lexical-lifetimes"));
 
 static llvm::cl::opt<bool>
 EnableExperimentalMoveOnly("enable-experimental-move-only",
@@ -519,13 +525,23 @@ int main(int argc, char **argv) {
   SILOpts.EnableOSSAModules = EnableOSSAModules;
   SILOpts.EnableCopyPropagation = EnableCopyPropagation;
   SILOpts.DisableCopyPropagation = DisableCopyPropagation;
-  SILOpts.EnableExperimentalLexicalLifetimes =
-      EnableExperimentalLexicalLifetimes;
-  // Also enable lexical lifetimes if experimental move only is enabled. This is
-  // because move only depends on lexical lifetimes being enabled and it saved
-  // some typing ; ).
-  SILOpts.EnableExperimentalLexicalLifetimes |=
-    EnableExperimentalMoveOnly;
+
+  // Enable lexical lifetimes if it is set or if experimental move only is
+  // enabled. This is because move only depends on lexical lifetimes being
+  // enabled and it saved some typing ; ).
+  bool enableExperimentalLexicalLifetimes =
+      EnableExperimentalLexicalLifetimes | EnableExperimentalMoveOnly;
+  if (enableExperimentalLexicalLifetimes && DisableLexicalLifetimes) {
+    fprintf(
+        stderr,
+        "Error! Can not specify both -enable-experimental-lexical-lifetimes "
+        "and -disable-lexical-lifetimes!\n");
+    exit(-1);
+  }
+  if (enableExperimentalLexicalLifetimes)
+    SILOpts.LexicalLifetimes = LexicalLifetimesOption::ExperimentalLate;
+  if (DisableLexicalLifetimes)
+    SILOpts.LexicalLifetimes = LexicalLifetimesOption::Off;
 
   serialization::ExtendedValidationInfo extendedInfo;
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
