[SILOptimizer] Add pipeline execution request (swiftlang#29552)

[SILOptimizer] Add pipeline execution request

Author: hamishknight

include/swift/AST/ASTContext.h

@@ -110,6 +110,7 @@ namespace swift {
   struct RawComment;
   class DocComment;
   class SILBoxType;
+  class SILTransform;
   class TypeAliasDecl;
   class VarDecl;
   class UnifiedStatsReporter;
@@ -978,6 +979,15 @@ class ASTContext final {
   /// Each kind and SourceFile has its own cache for a Type.
   Type &getDefaultTypeRequestCache(SourceFile *, KnownProtocolKind);
 
+  using SILTransformCtors = ArrayRef<SILTransform *(*)(void)>;
+
+  /// Register IRGen specific SIL passes such that the SILOptimizer can access
+  /// and execute them without directly depending on IRGen.
+  void registerIRGenSILTransforms(SILTransformCtors fns);
+
+  /// Retrieve the IRGen specific SIL passes.
+  SILTransformCtors getIRGenSILTransforms() const;
+
 private:
   friend Decl;
   Optional<RawComment> getRawComment(const Decl *D);

include/swift/AST/SILOptimizerRequests.h

@@ -0,0 +1,96 @@
+//===--- SILOptimizerRequests.h - SILOptimizer Requests ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines SILOptimizer requests.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_REQUESTS_H
+#define SWIFT_SILOPTIMIZER_REQUESTS_H
+
+#include "swift/AST/ASTTypeIDs.h"
+#include "swift/AST/SimpleRequest.h"
+
+namespace swift {
+
+namespace irgen {
+class IRGenModule;
+}
+
+class SILModule;
+class SILPassPipelinePlan;
+
+struct SILPipelineExecutionDescriptor {
+  SILModule *SM;
+
+  // Note that we currently store a reference to the pipeline plan on the stack.
+  // If ExecuteSILPipelineRequest ever becomes cached, we will need to adjust
+  // this.
+  const SILPassPipelinePlan &Plan;
+  bool IsMandatory;
+  irgen::IRGenModule *IRMod;
+
+  bool operator==(const SILPipelineExecutionDescriptor &other) const;
+  bool operator!=(const SILPipelineExecutionDescriptor &other) const {
+    return !(*this == other);
+  }
+};
+
+llvm::hash_code hash_value(const SILPipelineExecutionDescriptor &desc);
+
+/// Executes a SIL pipeline plan on a SIL module.
+class ExecuteSILPipelineRequest
+    : public SimpleRequest<ExecuteSILPipelineRequest,
+                           bool(SILPipelineExecutionDescriptor),
+                           CacheKind::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator,
+                                SILPipelineExecutionDescriptor desc) const;
+};
+
+void simple_display(llvm::raw_ostream &out,
+                    const SILPipelineExecutionDescriptor &desc);
+
+SourceLoc extractNearestSourceLoc(const SILPipelineExecutionDescriptor &desc);
+
+/// Report that a request of the given kind is being evaluated, so it
+/// can be recorded by the stats reporter.
+template <typename Request>
+void reportEvaluatedRequest(UnifiedStatsReporter &stats,
+                            const Request &request);
+
+/// The zone number for SILOptimizer.
+#define SWIFT_TYPEID_ZONE SILOptimizer
+#define SWIFT_TYPEID_HEADER "swift/AST/SILOptimizerTypeIDZone.def"
+#include "swift/Basic/DefineTypeIDZone.h"
+#undef SWIFT_TYPEID_ZONE
+#undef SWIFT_TYPEID_HEADER
+
+// Set up reporting of evaluated requests.
+#define SWIFT_REQUEST(Zone, RequestType, Sig, Caching, LocOptions)             \
+template<>                                                                     \
+inline void reportEvaluatedRequest(UnifiedStatsReporter &stats,                \
+                                   const RequestType &request) {               \
+  ++stats.getFrontendCounters().RequestType;                                   \
+}
+#include "swift/AST/SILOptimizerTypeIDZone.def"
+#undef SWIFT_REQUEST
+
+} // end namespace swift
+
+#endif // SWIFT_SILOPTIMIZER_REQUESTS_H

include/swift/AST/SILOptimizerTypeIDZone.def

@@ -0,0 +1,18 @@
+//===--- SILOptimizerTypeIDZone.def -----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This definition file describes the requests in SILOptimizer's zone.
+//
+//===----------------------------------------------------------------------===//
+
+SWIFT_REQUEST(SILOptimizer, ExecuteSILPipelineRequest,
+              bool(SILPipelineExecutionDescriptor), Uncached, NoLocationInfo)

include/swift/Basic/Statistics.def

@@ -280,6 +280,10 @@ FRONTEND_STATISTIC(SILModule, NumSILGenWitnessTables)
 FRONTEND_STATISTIC(SILModule, NumSILGenDefaultWitnessTables)
 FRONTEND_STATISTIC(SILModule, NumSILGenGlobalVariables)
 
+#define SWIFT_REQUEST(ZONE, NAME, Sig, Caching, LocOptions) FRONTEND_STATISTIC(SILOptimizer, NAME)
+#include "swift/AST/SILOptimizerTypeIDZone.def"
+#undef SWIFT_REQUEST
+
 FRONTEND_STATISTIC(SILModule, NumSILOptFunctions)
 FRONTEND_STATISTIC(SILModule, NumSILOptVtables)
 FRONTEND_STATISTIC(SILModule, NumSILOptWitnessTables)

include/swift/Basic/TypeID.h

@@ -38,6 +38,7 @@ enum class Zone : uint8_t {
   Parse                   = 8,
   TypeChecker             = 10,
   SILGen                  = 12,
+  SILOptimizer            = 13,
   TBDGen                  = 14,
   // N.B. This is not a formal zone and exists solely to support the unit tests.
   ArithmeticEvaluator     = 255,

include/swift/SIL/SILModule.h

@@ -777,6 +777,13 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SILModule &M){
   return OS;
 }
 
+/// Print a simple description of a SILModule for the request evaluator.
+void simple_display(llvm::raw_ostream &out, const SILModule *M);
+
+/// Retrieve a SourceLoc for a SILModule that the request evaluator can use for
+/// diagnostics.
+SourceLoc extractNearestSourceLoc(const SILModule *SM);
+
 namespace Lowering {
 /// Determine whether the given class will be allocated/deallocated using the
 /// Objective-C runtime, i.e., +alloc and -dealloc.

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -37,8 +37,15 @@ namespace irgen {
 class IRGenModule;
 }
 
+/// The main entrypoint for executing a pipeline pass on a SIL module.
+void executePassPipelinePlan(SILModule *SM, const SILPassPipelinePlan &plan,
+                             bool isMandatory = false,
+                             irgen::IRGenModule *IRMod = nullptr);
+
 /// The SIL pass manager.
 class SILPassManager {
+  friend class ExecuteSILPipelineRequest;
+
   /// The module that the pass manager will transform.
   SILModule *Mod;
 
@@ -99,9 +106,6 @@ class SILPassManager {
   /// OptimizationMode::NoOptimization.
   bool isMandatory = false;
 
-  /// The IRGen SIL passes. These have to be dynamically added by IRGen.
-  llvm::DenseMap<unsigned, SILTransform *> IRGenPasses;
-
   /// The notification handler for this specific SILPassManager.
   ///
   /// This is not owned by the pass manager, it is owned by the SILModule which
@@ -110,20 +114,12 @@ class SILPassManager {
   /// pass manager is destroyed.
   DeserializationNotificationHandler *deserializationNotificationHandler;
 
-public:
   /// C'tor. It creates and registers all analysis passes, which are defined
-  /// in Analysis.def.
-  ///
-  /// If \p isMandatory is true, passes are also run for functions
-  /// which have OptimizationMode::NoOptimization.
-  SILPassManager(SILModule *M, llvm::StringRef Stage = "",
-                 bool isMandatory = false);
-
-  /// C'tor. It creates an IRGen pass manager. Passes can query for the
-  /// IRGenModule.
-  SILPassManager(SILModule *M, irgen::IRGenModule *IRMod,
-                 llvm::StringRef Stage = "", bool isMandatory = false);
+  /// in Analysis.def. This is private as it should only be used by
+  /// ExecuteSILPipelineRequest.
+  SILPassManager(SILModule *M, bool isMandatory, irgen::IRGenModule *IRMod);
 
+public:
   const SILOptions &getOptions() const;
 
   /// Searches for an analysis of type T in the list of registered
@@ -269,15 +265,6 @@ class SILPassManager {
     }
   }
 
-  void registerIRGenPass(PassKind Kind, SILTransform *Transform) {
-    assert(IRGenPasses.find(unsigned(Kind)) == IRGenPasses.end() &&
-           "Pass already registered");
-    assert(
-        IRMod &&
-        "Attempting to register an IRGen pass with a non-IRGen pass manager");
-    IRGenPasses[unsigned(Kind)] = Transform;
-  }
-
 private:
   void execute();
 

include/swift/SILOptimizer/PassManager/PassPipeline.h

@@ -28,6 +28,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/SILOptimizer/PassManager/PassPipeline.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
+#include "llvm/ADT/Hashing.h"
 #include <vector>
 
 namespace swift {
@@ -98,12 +99,50 @@ class SILPassPipelinePlan final {
   PipelineRange getPipelines() const {
     return {PipelineStages.begin(), PipelineStages.end()};
   }
+
+  friend bool operator==(const SILPassPipelinePlan &lhs,
+                         const SILPassPipelinePlan &rhs) {
+    // FIXME: Comparing the SILOptions by identity should work in practice, but
+    // we don't currently prevent them from being copied. We should consider
+    // either making them move-only, or properly implementing == for them.
+    return &lhs.Options == &rhs.Options && lhs.Kinds == rhs.Kinds &&
+           lhs.PipelineStages == rhs.PipelineStages;
+  }
+
+  friend bool operator!=(const SILPassPipelinePlan &lhs,
+                         const SILPassPipelinePlan &rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend llvm::hash_code hash_value(const SILPassPipelinePlan &plan) {
+    using namespace llvm;
+    auto &kinds = plan.Kinds;
+    auto &stages = plan.PipelineStages;
+    return hash_combine(&plan.Options,
+                        hash_combine_range(kinds.begin(), kinds.end()),
+                        hash_combine_range(stages.begin(), stages.end()));
+  }
 };
 
 struct SILPassPipeline final {
   unsigned ID;
   StringRef Name;
   unsigned KindOffset;
+
+  friend bool operator==(const SILPassPipeline &lhs,
+                         const SILPassPipeline &rhs) {
+    return lhs.ID == rhs.ID && lhs.Name.equals(rhs.Name) &&
+           lhs.KindOffset == rhs.KindOffset;
+  }
+
+  friend bool operator!=(const SILPassPipeline &lhs,
+                         const SILPassPipeline &rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend llvm::hash_code hash_value(const SILPassPipeline &pipeline) {
+    return llvm::hash_combine(pipeline.ID, pipeline.Name, pipeline.KindOffset);
+  }
 };
 
 inline void SILPassPipelinePlan::startPipeline(StringRef Name) {

include/swift/Subsystems.h

@@ -368,6 +368,12 @@ namespace swift {
   /// should call this functions after forming the ASTContext.
   void registerSILGenRequestFunctions(Evaluator &evaluator);
 
+  /// Register SILOptimizer-level request functions with the evaluator.
+  ///
+  /// Clients that form an ASTContext and will perform any SIL optimization
+  /// should call this functions after forming the ASTContext.
+  void registerSILOptimizerRequestFunctions(Evaluator &evaluator);
+
   /// Register TBDGen-level request functions with the evaluator.
   ///
   /// Clients that form an ASTContext and will perform any TBD generation
@@ -385,6 +391,9 @@ namespace swift {
   /// Calling registerIDERequestFunctions will invoke this function as well.
   void registerIDETypeCheckRequestFunctions(Evaluator &evaluator);
 
+  /// Register SILOptimizer passes necessary for IRGen.
+  void registerIRGenSILTransforms(ASTContext &ctx);
+
 } // end namespace swift
 
 #endif // SWIFT_SUBSYSTEMS_H

lib/AST/ASTContext.cpp

@@ -473,6 +473,9 @@ struct ASTContext::Implementation {
   llvm::DenseMap<OverrideSignatureKey, GenericSignature> overrideSigCache;
 
   Optional<ClangTypeConverter> Converter;
+
+  /// The IRGen specific SIL transforms that have been registered.
+  SILTransformCtors IRGenSILPasses;
 };
 
 ASTContext::Implementation::Implementation()
@@ -4576,6 +4579,17 @@ bool ASTContext::overrideGenericSignatureReqsSatisfied(
   llvm_unreachable("Unhandled OverrideGenericSignatureReqCheck in switch");
 }
 
+void ASTContext::registerIRGenSILTransforms(SILTransformCtors ctors) {
+  assert(getImpl().IRGenSILPasses.empty() && "Already registered");
+  getImpl().IRGenSILPasses = ctors;
+}
+
+ASTContext::SILTransformCtors ASTContext::getIRGenSILTransforms() const {
+  auto passes = getImpl().IRGenSILPasses;
+  assert(!passes.empty() && "Didn't register the necessary passes");
+  return passes;
+}
+
 SILLayout *SILLayout::get(ASTContext &C,
                           CanGenericSignature Generics,
                           ArrayRef<SILField> Fields) {