libswift: infrastructure to define "instruction" passes.

Instruction passes are basically visit functions in SILCombine for a specific instruction type.
With the macro SWIFT_INSTRUCTION_PASS such a pass can be declared in Passes.def.
SILCombine then calls the run function of the pass in libswift.

Author: eeckstein

include/swift/SIL/SILInstructionWorklist.h

@@ -35,6 +35,7 @@
 
 #include "swift/Basic/BlotSetVector.h"
 #include "swift/SIL/SILInstruction.h"
+#include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "llvm/ADT/DenseMap.h"
@@ -65,13 +66,20 @@ template <typename VectorT = std::vector<SILInstruction *>,
 class SILInstructionWorklist : SILInstructionWorklistBase {
   BlotSetVector<SILInstruction *, VectorT, MapT> worklist;
 
+  /// For invoking Swift instruction passes in libswift.
+  LibswiftPassInvocation *libswiftPassInvocation = nullptr;
+
   void operator=(const SILInstructionWorklist &rhs) = delete;
   SILInstructionWorklist(const SILInstructionWorklist &worklist) = delete;
 
 public:
   SILInstructionWorklist(const char *loggingName = "InstructionWorklist")
       : SILInstructionWorklistBase(loggingName) {}
 
+  void setLibswiftPassInvocation(LibswiftPassInvocation *invocation) {
+    libswiftPassInvocation = invocation;
+  }
+
   /// Returns true if the worklist is empty.
   bool isEmpty() const { return worklist.empty(); }
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -24,10 +24,20 @@ typedef struct {
   BridgedPassContext passContext;
 } BridgedFunctionPassCtxt;
 
+typedef struct {
+  BridgedInstruction instruction;
+  BridgedPassContext passContext;
+} BridgedInstructionPassCtxt;
+
 typedef void (*BridgedFunctionPassRunFn)(BridgedFunctionPassCtxt);
+typedef void (*BridgedInstructionPassRunFn)(BridgedInstructionPassCtxt);
+
 void SILPassManager_registerFunctionPass(BridgedStringRef name,
                                          BridgedFunctionPassRunFn runFn);
 
+void SILCombine_registerInstructionPass(BridgedStringRef name,
+                                        BridgedInstructionPassRunFn runFn);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

include/swift/SILOptimizer/PassManager/Passes.def

@@ -64,6 +64,31 @@
         SWIFT_FUNCTION_PASS(Id, Tag, Description)
 #endif
 
+/// SWIFT_INSTRUCTION_PASS(Inst, Tag)
+///   Similar to SWIFT_FUNCTION_PASS, but defines an instruction pass which is
+///   implemented in libswift and is run by the SILCombiner.
+///   The \p Inst argument specifies the instruction class, and \p Tag a name
+///   for the pass.
+///
+///   No further code is need on the C++ side. In libswift an instruction pass
+///   with the same name must be registered with 'registerPass()'.
+///
+#ifndef SWIFT_INSTRUCTION_PASS
+#define SWIFT_INSTRUCTION_PASS(Inst, Tag)
+#endif
+
+/// SWIFT_INSTRUCTION_PASS_WITH_LEGACY(Inst, Tag)
+///   Like SWIFT_INSTRUCTION_PASS, but the a C++ legacy SILCombine visit
+///   function is used if the not
+///   built with libswift.
+///   The C++ legacy visit function must be named
+///   'SILCombiner::legacyVisit<Inst>'.
+///
+#ifndef SWIFT_INSTRUCTION_PASS_WITH_LEGACY
+#define SWIFT_INSTRUCTION_PASS_WITH_LEGACY(Inst, Tag) \
+        SWIFT_INSTRUCTION_PASS(Inst, Tag)
+#endif
+
 /// PASS_RANGE(RANGE_ID, START, END)
 ///   Pass IDs between PassKind::START and PassKind::END, inclusive,
 ///   fall within the set known as
@@ -399,5 +424,7 @@ PASS_RANGE(AllPasses, AADumper, PruneVTables)
 #undef IRGEN_PASS
 #undef SWIFT_FUNCTION_PASS
 #undef SWIFT_FUNCTION_PASS_WITH_LEGACY
+#undef SWIFT_INSTRUCTION_PASS
+#undef SWIFT_INSTRUCTION_PASS_WITH_LEGACY
 #undef PASS
 #undef PASS_RANGE

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1099,14 +1099,6 @@ FixedSizeSlab *LibswiftPassInvocation::freeSlab(FixedSizeSlab *slab) {
   return prev;
 }
 
-void LibswiftPassInvocation::eraseInstruction(SILInstruction *inst) {
-  if (silCombiner) {
-    // TODO
-  } else {
-    inst->eraseFromParent();
-  }
-}
-
 void LibswiftPassInvocation::finishedPassRun() {
   assert(allocatedSlabs.empty() && "StackList is leaking slabs");
 }

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -23,13 +23,14 @@
 #include "SILCombiner.h"
 #include "swift/SIL/BasicBlockDatastructures.h"
 #include "swift/SIL/DebugUtils.h"
+#include "swift/SIL/SILBridgingUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SILOptimizer/Analysis/AliasAnalysis.h"
 #include "swift/SILOptimizer/Analysis/DominanceAnalysis.h"
 #include "swift/SILOptimizer/Analysis/NonLocalAccessBlockAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SimplifyInstruction.h"
-#include "swift/SILOptimizer/PassManager/Passes.h"
+#include "swift/SILOptimizer/PassManager/PassManager.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CanonicalOSSALifetime.h"
 #include "swift/SILOptimizer/Utils/CanonicalizeInstruction.h"
@@ -378,6 +379,56 @@ void SILCombiner::eraseInstIncludingUsers(SILInstruction *inst) {
   eraseInstFromFunction(*inst);
 }
 
+/// Runs an instruction pass in libswift.
+void SILCombiner::runSwiftInstructionPass(SILInstruction *inst,
+                              void (*runFunction)(BridgedInstructionPassCtxt)) {
+  Worklist.setLibswiftPassInvocation(&libswiftPassInvocation);
+  runFunction({ {inst->asSILNode()}, {&libswiftPassInvocation} });
+  Worklist.setLibswiftPassInvocation(nullptr);
+  libswiftPassInvocation.finishedPassRun();
+}
+
+/// Registered briged instruction pass run functions.
+static llvm::StringMap<BridgedInstructionPassRunFn> libswiftInstPasses;
+static bool passesRegistered = false;
+
+// Called from libswift's initializeLibSwift().
+void SILCombine_registerInstructionPass(BridgedStringRef name,
+                                        BridgedInstructionPassRunFn runFn) {
+  libswiftInstPasses[getStringRef(name)] = runFn;
+  passesRegistered = true;
+}
+
+#define SWIFT_INSTRUCTION_PASS_COMMON(INST, TAG, LEGACY_RUN) \
+SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
+  static BridgedInstructionPassRunFn runFunction = nullptr;                \
+  static bool runFunctionSet = false;                                      \
+  if (!runFunctionSet) {                                                   \
+    runFunction = libswiftInstPasses[TAG];                                 \
+    if (!runFunction && passesRegistered) {                                \
+      llvm::errs() << "Swift pass " << TAG << " is not registered\n";      \
+      abort();                                                             \
+    }                                                                      \
+    runFunctionSet = true;                                                 \
+  }                                                                        \
+  if (!runFunction) {                                                      \
+    LEGACY_RUN;                                                            \
+  }                                                                        \
+  runSwiftInstructionPass(inst, runFunction);                              \
+  return nullptr;                                                          \
+}                                                                          \
+
+#define PASS(ID, TAG, DESCRIPTION)
+
+#define SWIFT_INSTRUCTION_PASS(INST, TAG) \
+  SWIFT_INSTRUCTION_PASS_COMMON(INST, TAG, { return nullptr; })
+
+#define SWIFT_INSTRUCTION_PASS_WITH_LEGACY(INST, TAG) \
+  SWIFT_INSTRUCTION_PASS_COMMON(INST, TAG, { return legacyVisit##INST(inst); })
+
+#include "swift/SILOptimizer/PassManager/Passes.def"
+
+#undef SWIFT_INSTRUCTION_PASS_COMMON
 
 //===----------------------------------------------------------------------===//
 //                                Entry Points
@@ -419,3 +470,15 @@ class SILCombine : public SILFunctionTransform {
 SILTransform *swift::createSILCombine() {
   return new SILCombine();
 }
+
+//===----------------------------------------------------------------------===//
+//                          SwiftFunctionPassContext
+//===----------------------------------------------------------------------===//
+
+void LibswiftPassInvocation::eraseInstruction(SILInstruction *inst) {
+  if (silCombiner) {
+    silCombiner->eraseInstFromFunction(*inst);
+  } else {
+    inst->eraseFromParent();
+  }
+}

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -28,13 +28,17 @@
 #include "swift/SIL/SILInstructionWorklist.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILVisitor.h"
+#include "swift/SIL/InstructionUtils.h"
 #include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
 #include "swift/SILOptimizer/Analysis/NonLocalAccessBlockAnalysis.h"
 #include "swift/SILOptimizer/Analysis/ProtocolConformanceAnalysis.h"
+#include "swift/SILOptimizer/OptimizerBridging.h"
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
 #include "swift/SILOptimizer/Utils/Existential.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "swift/SILOptimizer/Utils/OwnershipOptUtils.h"
+#include "swift/SILOptimizer/PassManager/PassManager.h"
+
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
@@ -101,6 +105,9 @@ class SILCombiner :
 
   /// External context struct used by \see ownershipRAUWHelper.
   OwnershipFixupContext ownershipFixupContext;
+  
+  /// For invoking Swift instruction passes in libswift.
+  LibswiftPassInvocation libswiftPassInvocation;
 
 public:
   SILCombiner(SILFunctionTransform *parentTransform,
@@ -145,7 +152,8 @@ class SILCombiner :
                         /* EraseAction */
                         [&](SILInstruction *I) { eraseInstFromFunction(*I); }),
         deBlocks(&B.getFunction()),
-        ownershipFixupContext(getInstModCallbacks(), deBlocks) {}
+        ownershipFixupContext(getInstModCallbacks(), deBlocks),
+        libswiftPassInvocation(parentTransform->getPassManager(), this) {}
 
   bool runOnFunction(SILFunction &F);
 
@@ -323,6 +331,12 @@ class SILCombiner :
   SILInstruction *
   visitConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *Cvt);
 
+#define PASS(ID, TAG, DESCRIPTION)
+#define SWIFT_FUNCTION_PASS(ID, TAG, DESCRIPTION)
+#define SWIFT_INSTRUCTION_PASS(INST, TAG) \
+  SILInstruction *visit##INST(INST *);
+#include "swift/SILOptimizer/PassManager/Passes.def"
+
   /// Instruction visitor helpers.
   SILInstruction *optimizeBuiltinCanBeObjCClass(BuiltinInst *AI);
 
@@ -453,6 +467,10 @@ class SILCombiner :
   bool hasOwnership() const {
     return Builder.hasOwnership();
   }
+  
+  void runSwiftInstructionPass(SILInstruction *inst,
+                               void (*runFunction)(BridgedInstructionPassCtxt));
+
 };
 
 } // end namespace swift

libswift/README.md

@@ -83,6 +83,20 @@ To add a new function pass:
 
 All SIL modifications, which a pass can do, are going through the `FunctionPassContext` - the second parameter of its run-function. In other words, the context is the central place to make modifications. This enables automatic change notifications to the pass manager. Also, it makes it easier to build a concurrent pass manager in future.
 
+### Instruction Passes
+
+In addition to function passes, _libswift_ provides the infrastructure for instruction passes. Instruction passes are invoked from SILCombine (in the C++ SILOptimizer) and correspond to a visit-function in SILCombine.
+
+With instruction passes it's possible to implement small peephole optimizations for certain instruction classes.
+
+To add a new instruction pass:
+
+* add a `SWIFT_INSTRUCTION_PASS` entry in `Passes.def`
+* create a new Swift file in `libswift/Sources/Optimizer/InstructionPasses`
+* add an `InstructionPass` global
+* register the pass in `registerSwiftPasses()`
+* if this passes replaces an existing `SILCombiner` visit function, remove the old visit function
+
 ## Performance
 
 The performance of _libswift_ is very important, because compile time is critical.

libswift/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -27,6 +27,14 @@ private func registerPass(
   }
 }
 
+private func registerPass<InstType: Instruction>(
+      _ pass: InstructionPass<InstType>,
+      _ runFn: @escaping (@convention(c) (BridgedInstructionPassCtxt) -> ())) {
+  pass.name.withBridgedStringRef { nameStr in
+    SILCombine_registerInstructionPass(nameStr, runFn)
+  }
+}
+
 private func registerSwiftPasses() {
   registerPass(silPrinterPass, { silPrinterPass.run($0) })
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })

libswift/Sources/Optimizer/PassManager/PassUtils.swift

@@ -15,6 +15,8 @@ import OptimizerBridging
 
 public typealias BridgedFunctionPassCtxt =
   OptimizerBridging.BridgedFunctionPassCtxt
+public typealias BridgedInstructionPassCtxt =
+  OptimizerBridging.BridgedInstructionPassCtxt
 
 struct FunctionPassContext {
 
@@ -49,10 +51,43 @@ struct FunctionPass {
   }
 }
 
+struct InstructionPassContext {
+  fileprivate let passContext: BridgedPassContext
+
+  func erase(instruction: Instruction) {
+    PassContext_eraseInstruction(passContext, instruction.bridged)
+  }
+
+  private func notifyChanges(_ kind: ChangeNotificationKind) {
+    PassContext_notifyChanges(passContext, kind)
+  }
+}
+
+struct InstructionPass<InstType: Instruction> {
+
+  let name: String
+  let runFunction: (InstType, InstructionPassContext) -> ()
+
+  public init(name: String, _ runFunction: @escaping (InstType, InstructionPassContext) -> ()) {
+    self.name = name
+    self.runFunction = runFunction
+  }
+
+  func run(_ bridgedCtxt: BridgedInstructionPassCtxt) {
+    let inst = bridgedCtxt.instruction.getAs(InstType.self)
+    let context = InstructionPassContext(passContext: bridgedCtxt.passContext)
+    runFunction(inst, context)
+  }
+}
+
 extension StackList {
   init(_ context: FunctionPassContext) {
     self.init(context: context.passContext)
   }
+  
+  init(_ context: InstructionPassContext) {
+    self.init(context: context.passContext)
+  }
 }
 
 extension Builder {
@@ -66,4 +101,15 @@ extension Builder {
     self.init(insertionPoint: insPnt, location: insPnt.location,
               passContext: context.passContext)
   }
+
+  init(at insPnt: Instruction, location: Location,
+       _ context: InstructionPassContext) {
+    self.init(insertionPoint: insPnt, location: location,
+              passContext: context.passContext)
+  }
+
+  init(at insPnt: Instruction, _ context: InstructionPassContext) {
+    self.init(insertionPoint: insPnt, location: insPnt.location,
+              passContext: context.passContext)
+  }
 }