libswift: Infrastructure to call libswift function passes from the SILOptimizer's PassManager

With the macro SWIFT_FUNCTION_PASS a new libswift function pass can be defined in Passes.def.
The SWIFT_FUNCTION_PASS_WITH_LEGACY is similar, but it allows to keep an original C++ “legacy” implementation of the pass, which is used if the compiler is not built with libswift.

Author: eeckstein

include/swift/SIL/SILBridging.h

@@ -40,6 +40,10 @@ enum ChangeNotificationKind {
   branchesChanged
 };
 
+typedef struct {
+  const void * _Nonnull opaqueCtxt;
+} BridgedPassContext;
+
 typedef struct {
   void * _Null_unspecified word0;
   void * _Null_unspecified word1;
@@ -113,6 +117,11 @@ void registerBridgedClass(BridgedStringRef className, SwiftMetatype metatype);
 
 void freeBridgedStringRef(BridgedStringRef str);
 
+void PassContext_notifyChanges(BridgedPassContext passContext,
+                               enum ChangeNotificationKind changeKind);
+void PassContext_eraseInstruction(BridgedPassContext passContext,
+                                  BridgedInstruction inst);
+
 BridgedStringRef SILFunction_getName(BridgedFunction function);
 BridgedStringRef SILFunction_debugDescription(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_firstBlock(BridgedFunction function);

include/swift/SIL/SILInstruction.h

@@ -365,10 +365,15 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   SILInstructionResultArray getResultsImpl() const;
 
 protected:
+  friend class LibswiftPassInvocation;
+
   SILInstruction() {
     NumCreatedInstructions++;
   }
 
+  /// This method unlinks 'self' from the containing basic block.
+  void removeFromParent();
+
   ~SILInstruction() {
     NumDeletedInstructions++;
   }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -0,0 +1,35 @@
+//===--- OptimizerBridging.h - header for the OptimizerBridging module ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_OPTIMIZERBRIDGING_H
+#define SWIFT_SILOPTIMIZER_OPTIMIZERBRIDGING_H
+
+#include "../SIL/SILBridging.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  BridgedFunction function;
+  BridgedPassContext passContext;
+} BridgedFunctionPassCtxt;
+
+typedef void (*BridgedFunctionPassRunFn)(BridgedFunctionPassCtxt);
+void SILPassManager_registerFunctionPass(BridgedStringRef name,
+                                         BridgedFunctionPassRunFn runFn);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SIL/Notifications.h"
+#include "swift/SIL/InstructionUtils.h"
 #include "swift/SILOptimizer/Analysis/Analysis.h"
 #include "swift/SILOptimizer/PassManager/PassPipeline.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
@@ -31,6 +32,8 @@ class SILModule;
 class SILModuleTransform;
 class SILOptions;
 class SILTransform;
+class SILPassManager;
+class SILCombiner;
 
 namespace irgen {
 class IRGenModule;
@@ -41,6 +44,28 @@ void executePassPipelinePlan(SILModule *SM, const SILPassPipelinePlan &plan,
                              bool isMandatory = false,
                              irgen::IRGenModule *IRMod = nullptr);
 
+/// Utility class to invoke passes in libswift.
+class LibswiftPassInvocation {
+  /// Backlink to the pass manager.
+  SILPassManager *passManager;
+  
+  /// Non-null if this is an instruction pass, invoked from SILCombine.
+  SILCombiner *silCombiner;
+
+public:
+  LibswiftPassInvocation(SILPassManager *passManager, SILCombiner *silCombiner) :
+    passManager(passManager), silCombiner(silCombiner) {}
+
+  /// The top-level API to erase an instruction, called from the Swift pass.
+  void eraseInstruction(SILInstruction *inst);
+
+  /// Called by the pass when changes are made to the SIL.
+  void notifyChanges(SILAnalysis::InvalidationKind invalidationKind);
+
+  /// Called by the pass manager when the pass has finished.
+  void finishedPassRun();
+};
+
 /// The SIL pass manager.
 class SILPassManager {
   friend class ExecuteSILPipelineRequest;
@@ -79,6 +104,13 @@ class SILPassManager {
   /// The number of passes run so far.
   unsigned NumPassesRun = 0;
 
+  /// For invoking Swift passes in libswift.
+  LibswiftPassInvocation libswiftPassInvocation;
+
+  /// Change notifications, collected during a bridged pass run.
+  SILAnalysis::InvalidationKind changeNotifications =
+      SILAnalysis::InvalidationKind::Nothing;
+
   /// A mask which has one bit for each pass. A one for a pass-bit means that
   /// the pass doesn't need to run, because nothing has changed since the
   /// previous run of that pass.
@@ -148,6 +180,10 @@ class SILPassManager {
   /// pass manager.
   irgen::IRGenModule *getIRGenModule() { return IRMod; }
 
+  LibswiftPassInvocation *getLibswiftPassInvocation() {
+    return &libswiftPassInvocation;
+  }
+
   /// Restart the function pass pipeline on the same function
   /// that is currently being processed.
   void restartWithCurrentFunction(SILTransform *T);
@@ -226,6 +262,11 @@ class SILPassManager {
     CompletedPassesMap[F].reset();
   }
 
+  void notifyPassChanges(SILAnalysis::InvalidationKind invalidationKind) {
+    changeNotifications = (SILAnalysis::InvalidationKind)
+        (changeNotifications | invalidationKind);
+  }
+
   /// Reset the state of the pass manager and remove all transformation
   /// owned by the pass manager. Analysis passes will be kept.
   void resetAndRemoveTransformations();
@@ -315,6 +356,11 @@ class SILPassManager {
   void viewCallGraph();
 };
 
+inline void LibswiftPassInvocation::
+notifyChanges(SILAnalysis::InvalidationKind invalidationKind) {
+  passManager->notifyPassChanges(invalidationKind);
+}
+
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/PassManager/Passes.def

@@ -43,6 +43,27 @@
 #define IRGEN_PASS(Id, Tag, Description) PASS(Id, Tag, Description)
 #endif
 
+/// SWIFT_FUNCTION_PASS(Id, Tag, Description)
+///   This macro follows the same conventions as PASS(Id, Tag, Description),
+///   but is used for function passes which are implemented in libswift.
+///
+///   No further code is need on the C++ side. In libswift a function pass with
+///   the same name must be registered with 'registerPass()'.
+///
+#ifndef SWIFT_FUNCTION_PASS
+#define SWIFT_FUNCTION_PASS(Id, Tag, Description) PASS(Id, Tag, Description)
+#endif
+
+/// SWIFT_FUNCTION_PASS_WITH_LEGACY(Id, Tag, Description)
+///   Like SWIFT_FUNCTION_PASS, but the a C++ legacy pass is used if the not
+///   built with libswift.
+///   The C++ legacy creation function must be named 'createLegacy<Id>'
+///
+#ifndef SWIFT_FUNCTION_PASS_WITH_LEGACY
+#define SWIFT_FUNCTION_PASS_WITH_LEGACY(Id, Tag, Description) \
+        SWIFT_FUNCTION_PASS(Id, Tag, Description)
+#endif
+
 /// PASS_RANGE(RANGE_ID, START, END)
 ///   Pass IDs between PassKind::START and PassKind::END, inclusive,
 ///   fall within the set known as
@@ -374,5 +395,7 @@ PASS(PruneVTables, "prune-vtables",
 PASS_RANGE(AllPasses, AADumper, PruneVTables)
 
 #undef IRGEN_PASS
+#undef SWIFT_FUNCTION_PASS
+#undef SWIFT_FUNCTION_PASS_WITH_LEGACY
 #undef PASS
 #undef PASS_RANGE

include/swift/SILOptimizer/PassManager/Passes.h

@@ -74,7 +74,11 @@ namespace swift {
   StringRef PassKindID(PassKind Kind);
   StringRef PassKindTag(PassKind Kind);
 
-#define PASS(ID, TAG, NAME) SILTransform *create##ID();
+#define PASS(ID, TAG, NAME) \
+  SILTransform *create##ID();
+#define SWIFT_FUNCTION_PASS_WITH_LEGACY(ID, TAG, NAME) \
+  PASS(ID, TAG, NAME) \
+  SILTransform *createLegacy##ID();
 #define IRGEN_PASS(ID, TAG, NAME)
 #include "Passes.def"
 

include/swift/module.modulemap

@@ -3,3 +3,8 @@ module SILBridging {
   export *
 }
 
+module OptimizerBridging {
+  header "SILOptimizer/OptimizerBridging.h"
+  export *
+}
+

lib/SIL/IR/SILInstruction.cpp

@@ -103,6 +103,16 @@ SILModule &SILInstruction::getModule() const {
   return getFunction()->getModule();
 }
 
+void SILInstruction::removeFromParent() {
+#ifndef NDEBUG
+  for (auto result : getResults()) {
+    assert(result->use_empty() && "Uses of SILInstruction remain at deletion.");
+  }
+#endif
+  getParent()->remove(this);
+  ParentBB = nullptr;
+}
+
 /// eraseFromParent - This method unlinks 'self' from the containing basic
 /// block and deletes it.
 ///

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -16,10 +16,12 @@
 #include "swift/AST/SILOptimizerRequests.h"
 #include "swift/Demangling/Demangle.h"
 #include "swift/SIL/ApplySite.h"
+#include "swift/SIL/SILBridgingUtils.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h"
 #include "swift/SILOptimizer/Analysis/FunctionOrder.h"
+#include "swift/SILOptimizer/OptimizerBridging.h"
 #include "swift/SILOptimizer/PassManager/PrettyStackTrace.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/OptimizerStatsUtils.h"
@@ -318,8 +320,9 @@ void swift::executePassPipelinePlan(SILModule *SM,
 
 SILPassManager::SILPassManager(SILModule *M, bool isMandatory,
                                irgen::IRGenModule *IRMod)
-    : Mod(M), IRMod(IRMod), isMandatory(isMandatory),
-      deserializationNotificationHandler(nullptr) {
+    : Mod(M), IRMod(IRMod),
+      libswiftPassInvocation(this, /*SILCombiner*/ nullptr),
+      isMandatory(isMandatory), deserializationNotificationHandler(nullptr) {
 #define ANALYSIS(NAME) \
   Analyses.push_back(create##NAME##Analysis(Mod));
 #include "swift/SILOptimizer/Analysis/Analysis.def"
@@ -462,7 +465,19 @@ void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
                        SILForceVerifyAroundPass.end(), MatchFun)) {
     forcePrecomputeAnalyses(F);
   }
+  
+  assert(changeNotifications == SILAnalysis::InvalidationKind::Nothing
+         && "change notifications not cleared");
+  
+  // Run it!
   SFT->run();
+
+  if (changeNotifications != SILAnalysis::InvalidationKind::Nothing) {
+    invalidateAnalysis(F, changeNotifications);
+    changeNotifications = SILAnalysis::InvalidationKind::Nothing;
+  }
+  libswiftPassInvocation.finishedPassRun();
+
   if (SILForceVerifyAll ||
       SILForceVerifyAroundPass.end() !=
           std::find_if(SILForceVerifyAroundPass.begin(),
@@ -1059,3 +1074,49 @@ void SILPassManager::viewCallGraph() {
   llvm::ViewGraph(&OCG, "callgraph");
 #endif
 }
+
+//===----------------------------------------------------------------------===//
+//                           LibswiftPassInvocation
+//===----------------------------------------------------------------------===//
+
+void LibswiftPassInvocation::eraseInstruction(SILInstruction *inst) {
+  if (silCombiner) {
+    // TODO
+  } else {
+    inst->eraseFromParent();
+  }
+}
+
+void LibswiftPassInvocation::finishedPassRun() {
+}
+
+//===----------------------------------------------------------------------===//
+//                            Swift Bridging
+//===----------------------------------------------------------------------===//
+
+inline LibswiftPassInvocation *castToPassInvocation(BridgedPassContext ctxt) {
+  return const_cast<LibswiftPassInvocation *>(
+    static_cast<const LibswiftPassInvocation *>(ctxt.opaqueCtxt));
+}
+
+void PassContext_notifyChanges(BridgedPassContext passContext,
+                               enum ChangeNotificationKind changeKind) {
+  LibswiftPassInvocation *inv = castToPassInvocation(passContext);
+  switch (changeKind) {
+  case instructionsChanged:
+    inv->notifyChanges(SILAnalysis::InvalidationKind::Instructions);
+    break;
+  case callsChanged:
+    inv->notifyChanges(SILAnalysis::InvalidationKind::CallsAndInstructions);
+    break;
+  case branchesChanged:
+    inv->notifyChanges(SILAnalysis::InvalidationKind::BranchesAndInstructions);
+    break;
+  }
+}
+
+void PassContext_eraseInstruction(BridgedPassContext passContext,
+                                   BridgedInstruction inst) {
+  castToPassInvocation(passContext)->eraseInstruction(castToInst(inst));
+}
+