[Compile Time Values] Add mandatory optimization pipeline driver for '@const' globals

Author: artemcm

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/SimplificationPasses.swift

@@ -44,15 +44,6 @@ let ononeSimplificationPass = FunctionPass(name: "onone-simplification") {
   }
 }
 
-let constPropagationPass = FunctionPass(name: "const-propagation") {
-  (function: Function, context: FunctionPassContext) in
-  runSimplification(on: function, context, preserveDebugInfo: true) {
-    if let i = $0 as? OnoneSimplifiable {
-      i.simplify($1)
-    }
-  }
-}
-
 let simplificationPass = FunctionPass(name: "simplification") {
   (function: Function, context: FunctionPassContext) in
 

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -47,6 +47,15 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
   }
 }
 
+/// Performance the same set of top-down optimization as the above "mandatory-performance-optimizations"
+/// pass, but only on the initializers of '@const' globals.
+let constGlobalVariableFoldingPass = ModulePass(name: "const-global-variable-folding") {
+  (moduleContext: ModulePassContext) in
+  var worklist = FunctionWorklist()
+  worklist.addAllConstGlobalInitOnceFunctions(of: moduleContext)
+  optimizeFunctionsTopDown(using: &worklist, moduleContext)
+}
+
 private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
                                       _ moduleContext: ModulePassContext) {
   while let f = worklist.pop() {
@@ -506,6 +515,15 @@ fileprivate struct FunctionWorklist {
     }
   }
 
+  mutating func addAllConstGlobalInitOnceFunctions(of moduleContext: ModulePassContext) {
+    for f in moduleContext.functions where f.isGlobalInitOnceFunction {
+      if let global = f.getInitializedGlobal(),
+         global.isConst {
+        pushIfNotVisited(f)
+      }
+    }
+  }
+
   mutating func addCallees(of function: Function) {
     for inst in function.instructions {
       switch inst {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -64,6 +64,7 @@ private func registerForSILCombine<InstType: SILCombineSimplifiable>(
 private func registerSwiftPasses() {
   // Module passes
   registerPass(mandatoryPerformanceOptimizations, { mandatoryPerformanceOptimizations.run($0) })
+  registerPass(constGlobalVariableFoldingPass, { constGlobalVariableFoldingPass.run($0)})
   registerPass(readOnlyGlobalVariablesPass, { readOnlyGlobalVariablesPass.run($0) })
   registerPass(stackProtection, { stackProtection.run($0) })
 
@@ -85,7 +86,6 @@ private func registerSwiftPasses() {
   registerPass(releaseDevirtualizerPass, { releaseDevirtualizerPass.run($0) })
   registerPass(simplificationPass, { simplificationPass.run($0) })
   registerPass(ononeSimplificationPass, { ononeSimplificationPass.run($0) })
-  registerPass(constPropagationPass, { constPropagationPass.run($0) })
   registerPass(lateOnoneSimplificationPass, { lateOnoneSimplificationPass.run($0) })
   registerPass(cleanupDebugStepsPass, { cleanupDebugStepsPass.run($0) })
   registerPass(namedReturnValueOptimization, { namedReturnValueOptimization.run($0) })

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -71,6 +71,10 @@ final public class GlobalVariable : CustomStringConvertible, HasShortDescription
     return bridged.mustBeInitializedStatically()
   }
 
+  public var isConst: Bool {
+    return bridged.isConstVal()
+  }
+
   public static func ==(lhs: GlobalVariable, rhs: GlobalVariable) -> Bool {
     lhs === rhs
   }

include/swift/SIL/SILBridging.h

@@ -570,6 +570,7 @@ struct BridgedGlobalVar {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedInstruction getFirstStaticInitInst() const;
   bool canBeInitializedStatically() const;
   bool mustBeInitializedStatically() const;
+  bool isConstVal() const;
 };
 
 struct OptionalBridgedGlobalVar {

include/swift/SILOptimizer/PassManager/Passes.def

@@ -415,11 +415,39 @@ LEGACY_PASS(SILDebugInfoGenerator, "sil-debuginfo-gen",
      "Generate Debug Information with Source Locations into Textual SIL")
 LEGACY_PASS(EarlySROA, "early-sroa",
      "Scalar Replacement of Aggregate Stack Objects on high-level SIL")
-LEGACY_PASS(SROA, "sroa",
+SWIFT_MODULE_PASS(RunUnitTests, "run-unit-tests",
+     "Runs the compiler internal unit tests")
+SWIFT_FUNCTION_PASS(SILPrinter, "sil-printer",
+     "Test pass which prints the SIL of a function")
+SWIFT_MODULE_PASS(FunctionUsesDumper, "dump-function-uses",
+     "Dump the results of FunctionUses")
+SWIFT_MODULE_PASS(MandatoryPerformanceOptimizations, "mandatory-performance-optimizations",
+     "Performs optimizations for performance-annotated functions")
+SWIFT_MODULE_PASS(ConstGlobalVariableFoldingPass, "const-global-variable-folding",
+     "Performs simplification and folding of @const global variable initializers")
+SWIFT_MODULE_PASS(ReadOnlyGlobalVariablesPass, "read-only-global-variables",
+     "Converts read-only var-globals to let-globals")
+SWIFT_MODULE_PASS(StackProtection, "stack-protection",
+     "Decides which functions need stack protectors")
+SWIFT_FUNCTION_PASS(FunctionStackProtection, "function-stack-protection",
+     "Decides which functions need stack protectors")
+PASS(SROA, "sroa",
      "Scalar Replacement of Aggregate Stack Objects")
 LEGACY_PASS(SROABBArgs, "sroa-bb-args",
      "Scalar Replacement of Aggregate SIL Block Arguments")
-LEGACY_PASS(SimplifyBBArgs, "simplify-bb-args",
+SWIFT_FUNCTION_PASS(Simplification, "simplification",
+    "Peephole simplifications")
+SWIFT_FUNCTION_PASS(OnoneSimplification, "onone-simplification",
+    "Peephole simplifications which runs at -Onone")
+SWIFT_FUNCTION_PASS(LateOnoneSimplification, "late-onone-simplification",
+    "Peephole simplifications which can only run late in the -Onone pipeline")
+SWIFT_FUNCTION_PASS(CleanupDebugSteps, "cleanup-debug-steps",
+    "Cleanup debug_step instructions for Onone")
+SWIFT_FUNCTION_PASS(NamedReturnValueOptimization, "named-return-value-optimization",
+    "Optimize copies to an indirect return value")
+SWIFT_FUNCTION_PASS(StripObjectHeaders, "strip-object-headers",
+    "Sets the bare flag on objects which don't need their headers")
+PASS(SimplifyBBArgs, "simplify-bb-args",
      "SIL Block Argument Simplification")
 LEGACY_PASS(SpeculativeDevirtualization, "specdevirt",
      "Speculative Devirtualization via Guarded Calls")

lib/SIL/Utils/SILBridging.cpp

@@ -329,6 +329,11 @@ bool BridgedGlobalVar::mustBeInitializedStatically() const {
   return global->mustBeInitializedStatically();
 }
 
+bool BridgedGlobalVar::isConstVal() const {
+  SILGlobalVariable *global = getGlobal();
+  return global->getDecl()->isConstVal();
+}
+
 //===----------------------------------------------------------------------===//
 //                            SILDeclRef
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Mandatory/DiagnoseUnknownCompileTimeValues.cpp

@@ -91,29 +91,11 @@ class DiagnoseUnknownCompileTimeValues : public SILModuleTransform {
     }
   }
 
-  void verifyStaticallyInitializedGlobal(ConstExprFunctionState &ConstExprState,
-                                         SILGlobalVariable &Global,
-                                         VarDecl *Decl) {
-    LLVM_DEBUG(llvm::dbgs()
-                   << "@const static let " << Decl->getName().str().str()
-                   << ": " << Decl->getTypeInContext().getString() << " = ";);
-    auto StaticInitializerValue = Global.getStaticInitializerValue();
-    assert(StaticInitializerValue && "Expected a static initializer");
-    if (auto *SI = dyn_cast<StructInst>(StaticInitializerValue)) {
-      for (auto &SIO : SI->getAllOperands()) {
-        if (!ConstExprState.getConstantValue(SIO.get())
-                 .containsOnlyConstants()) {
-          Decl->diagnose(diag::require_const_initializer_for_const);
-          LLVM_DEBUG(llvm::dbgs() << "Unknown\n";);
-        } else
-          LLVM_DEBUG(printSymbolicValueValue(
-              ConstExprState.getConstantValue(SIO.get()), Allocator));
-      }
-    }
-  }
-
   void verifyInitializeOnceGlobal(ConstExprFunctionState &ConstExprState,
                                   SILGlobalVariable &Global, VarDecl *Decl) {
+    // TODO: Determine cases if/where this is necessary to perform,
+    // i.e. where we currently fail to simplify to a statically-initialized
+    // value.
     LLVM_DEBUG(llvm::dbgs()
                    << "@const [init_once] let " << Decl->getName().str().str()
                    << ": " << Decl->getTypeInContext().getString() << " = ";);
@@ -129,19 +111,11 @@ class DiagnoseUnknownCompileTimeValues : public SILModuleTransform {
             for (SILInstruction &I : BB) {
               if (auto *GlobalAddr = dyn_cast<GlobalAddrInst>(&I)) {
                 if (GlobalAddr->getReferencedGlobal() == &Global) {
-                  // Get the sole store to the global addr
-                  // ACTODO: check if single use valid/exists
-                  // Find sole store
-//                  for (auto *use : getNonDebugUses(existentialBox)) {
-//                    worklist.insert(use);
-//                  }
-
                   if (auto SingleUse = GlobalAddr->getSingleUse()) {
                     auto SoleUseUser = SingleUse->getUser();
                     assert(isa<StoreInst>(SoleUseUser));
-                    auto Value = ConstExprState.getConstantValue(
-                        dyn_cast<StoreInst>(SoleUseUser)->getSrc());
-
+                    auto src = dyn_cast<StoreInst>(SoleUseUser)->getSrc();
+                    auto Value = ConstExprState.getConstantValue(src);
                     if (Value.isConstant()) {
                       LLVM_DEBUG(printSymbolicValueValue(Value, Allocator););
                       return;
@@ -165,9 +139,29 @@ class DiagnoseUnknownCompileTimeValues : public SILModuleTransform {
     for (SILGlobalVariable &G : M->getSILGlobals()) {
       if (auto Decl = G.getDecl()) {
         if (Decl->isConstVal()) {
-          if (G.getStaticInitializerValue())
-            verifyStaticallyInitializedGlobal(ConstExprState, G, Decl);
-          else
+          if (G.getStaticInitializerValue()) {
+            // Presence of a static initializer alone confirms
+            // this to be a constant value.
+            LLVM_DEBUG(
+                llvm::dbgs()
+                    << "@const static let " << Decl->getName().str().str()
+                    << ": " << Decl->getTypeInContext().getString() << " = ";
+                auto StaticInitializerValue = G.getStaticInitializerValue();
+                assert(StaticInitializerValue &&
+                       "Expected a static initializer");
+                if (auto *SI = dyn_cast<StructInst>(StaticInitializerValue)) {
+                  for (auto &SIO : SI->getAllOperands()) {
+                    if (!ConstExprState.getConstantValue(SIO.get())
+                             .containsOnlyConstants())
+                      LLVM_DEBUG(llvm::dbgs()
+                                     << "Unknown to the Constant Evaluator\n";);
+                    else
+                      LLVM_DEBUG(printSymbolicValueValue(
+                          ConstExprState.getConstantValue(SIO.get()),
+                          Allocator));
+                  }
+                });
+          } else
             verifyInitializeOnceGlobal(ConstExprState, G, Decl);
         }
       }
@@ -244,8 +238,8 @@ class DiagnoseUnknownCompileTimeValues : public SILModuleTransform {
             printSymbolicValueValue(Value, Allocator);
           });
           if (!ConstExprState.getConstantValue(CorrespondingArg).isConstant()) {
-            // FIXME: Is there a way to get this source loc without going throuh
-            // the ApplyExpr?
+            // FIXME: Is there a way to get this source loc without going
+            // throuh the ApplyExpr?
             auto ArgLocation = Apply->getLoc().getSourceLoc();
             if (auto ApplyExprNode = Apply->getLoc().getAsASTNode<ApplyExpr>())
               ArgLocation = ApplyExprNode->getArgs()[i].getLoc();

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -262,7 +262,8 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
     P.addDeadFunctionAndGlobalElimination();
   }
 
-  P.addConstPropagation();
+  P.addConstGlobalVariableFoldingPass();
+  P.addOnoneSimplification();
   P.addDiagnoseUnknownCompileTimeValues();
 
   P.addPerformanceDiagnostics();