PassManager: cleanup Passes.def

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -252,7 +252,7 @@ class SILPassManager {
   /// 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.
-  typedef std::bitset<(size_t)PassKind::AllPasses_Last + 1> CompletedPasses;
+  typedef std::bitset<(size_t)PassKind::numPasses> CompletedPasses;
 
   /// A completed-passes mask for each function.
   llvm::DenseMap<SILFunction *, CompletedPasses> CompletedPassesMap;

include/swift/SILOptimizer/PassManager/Passes.h

@@ -65,9 +65,9 @@ namespace swift {
   /// lists of passes.
   enum class PassKind {
 #define PASS(ID, TAG, NAME) ID,
-#define PASS_RANGE(ID, START, END) ID##_First = START, ID##_Last = END,
 #include "Passes.def"
-    invalidPassKind
+    invalidPassKind,
+    numPasses = invalidPassKind,
   };
 
   PassKind PassKindFromString(StringRef ID);

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1202,8 +1202,7 @@ enum class IRGenPasses : uint8_t {
 } // end anonymous namespace
 
 void SILPassManager::addPass(PassKind Kind) {
-  assert(unsigned(PassKind::AllPasses_Last) >= unsigned(Kind) &&
-         "Invalid pass kind");
+  ASSERT(unsigned(PassKind::numPasses) > unsigned(Kind) && "Invalid pass kind");
   switch (Kind) {
 #define PASS(ID, TAG, NAME)                                                    \
   case PassKind::ID: {                                                         \

lib/SILOptimizer/PassManager/Passes.cpp

@@ -285,26 +285,26 @@ void SILPassManager_registerFunctionPass(BridgedStringRef name,
   passesRegistered = true;
 }
 
-#define PASS(ID, TAG, DESCRIPTION)
+#define LEGACY_PASS(ID, TAG, DESCRIPTION)
 
-#define SWIFT_MODULE_PASS(ID, TAG, DESCRIPTION) \
-class ID##Pass : public SILModuleTransform {                               \
-  static BridgedModulePassRunFn runFunction;                               \
+#define PASS(ID, TAG, DESCRIPTION) \
+class ID##Pass : public SILFunctionTransform {                             \
+  static BridgedFunctionPassRunFn runFunction;                             \
   void run() override {                                                    \
-    runBridgedModulePass(runFunction, PM, TAG);                            \
+    runBridgedFunctionPass(runFunction, PM, getFunction(), TAG);           \
   }                                                                        \
 };                                                                         \
-BridgedModulePassRunFn ID##Pass::runFunction = nullptr;                    \
+BridgedFunctionPassRunFn ID##Pass::runFunction = nullptr;                  \
 SILTransform *swift::create##ID() { return new ID##Pass(); }               \
 
-#define SWIFT_FUNCTION_PASS(ID, TAG, DESCRIPTION) \
-class ID##Pass : public SILFunctionTransform {                             \
-  static BridgedFunctionPassRunFn runFunction;                             \
+#define MODULE_PASS(ID, TAG, DESCRIPTION) \
+class ID##Pass : public SILModuleTransform {                               \
+  static BridgedModulePassRunFn runFunction;                               \
   void run() override {                                                    \
-    runBridgedFunctionPass(runFunction, PM, getFunction(), TAG);           \
+    runBridgedModulePass(runFunction, PM, TAG);                            \
   }                                                                        \
 };                                                                         \
-BridgedFunctionPassRunFn ID##Pass::runFunction = nullptr;                  \
+BridgedModulePassRunFn ID##Pass::runFunction = nullptr;                    \
 SILTransform *swift::create##ID() { return new ID##Pass(); }               \
 
 #include "swift/SILOptimizer/PassManager/Passes.def"

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -633,12 +633,12 @@ void SILCombine_registerInstructionPass(BridgedStringRef instClassName,
   runSwiftInstructionPass(inst, runFunction);                              \
   return nullptr;                                                          \
 
-#define SWIFT_SILCOMBINE_PASS(INST) \
+#define INSTRUCTION_SIMPLIFICATION(INST) \
 SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
   _RUN_SWIFT_SIMPLIFICATON(INST)                                           \
 }                                                                          \
 
-#define SWIFT_SILCOMBINE_PASS_WITH_LEGACY(INST) \
+#define INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(INST) \
 SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
   if (auto *result = legacyVisit##INST(inst))                              \
     return result;                                                         \
@@ -648,9 +648,7 @@ SILInstruction *SILCombiner::visit##INST(INST *inst) {                     \
   return nullptr;                                                          \
 }                                                                          \
 
-#define PASS(ID, TAG, DESCRIPTION)
-
-#include "swift/SILOptimizer/PassManager/Passes.def"
+#include "Simplifications.def"
 
 #undef _RUN_SWIFT_SIMPLIFICATON
 

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -301,14 +301,12 @@ class SILCombiner :
 
   SILInstruction *legacyVisitGlobalValueInst(GlobalValueInst *globalValue);
 
-#define PASS(ID, TAG, DESCRIPTION)
-#define SWIFT_FUNCTION_PASS(ID, TAG, DESCRIPTION)
-#define SWIFT_SILCOMBINE_PASS(INST) \
+#define INSTRUCTION_SIMPLIFICATION(INST) \
   SILInstruction *visit##INST(INST *);
-#define SWIFT_SILCOMBINE_PASS_WITH_LEGACY(INST) \
+#define INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(INST) \
   SILInstruction *visit##INST(INST *);          \
   SILInstruction *legacyVisit##INST(INST *);
-#include "swift/SILOptimizer/PassManager/Passes.def"
+#include "Simplifications.def"
 
   /// Instruction visitor helpers.
 

lib/SILOptimizer/SILCombiner/Simplifications.def

@@ -0,0 +1,57 @@
+//===--- Simplifications.def ------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 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 contains macro-metaprogramming for instruction simplifications
+// running in SILCombine.
+//
+//===----------------------------------------------------------------------===//
+
+/// INSTRUCTION_SIMPLIFICATION(Inst)
+///   Defines an instruction simplification which is implemented in swift and is
+///   run by the SILCombiner.
+///   The \p Inst argument specifies the instruction class.
+///
+///   No further code is need on the C++ side. On the swift side an instruction
+///   simplification must be registered for the instruction class with
+///   `registerForSILCombine`.
+///
+
+/// INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(Inst)
+///   Like INSTRUCTION_SIMPLIFICATION, but also runs the legacy `visitInst`
+///   implementation in SILCombine.
+
+INSTRUCTION_SIMPLIFICATION(BeginBorrowInst)
+INSTRUCTION_SIMPLIFICATION(BeginCOWMutationInst)
+INSTRUCTION_SIMPLIFICATION(ClassifyBridgeObjectInst)
+INSTRUCTION_SIMPLIFICATION(FixLifetimeInst)
+INSTRUCTION_SIMPLIFICATION(GlobalValueInst)
+INSTRUCTION_SIMPLIFICATION(StrongRetainInst)
+INSTRUCTION_SIMPLIFICATION(StrongReleaseInst)
+INSTRUCTION_SIMPLIFICATION(RetainValueInst)
+INSTRUCTION_SIMPLIFICATION(ReleaseValueInst)
+INSTRUCTION_SIMPLIFICATION(LoadInst)
+INSTRUCTION_SIMPLIFICATION(LoadBorrowInst)
+INSTRUCTION_SIMPLIFICATION(CopyValueInst)
+INSTRUCTION_SIMPLIFICATION(DestroyValueInst)
+INSTRUCTION_SIMPLIFICATION(DestructureStructInst)
+INSTRUCTION_SIMPLIFICATION(DestructureTupleInst)
+INSTRUCTION_SIMPLIFICATION(PointerToAddressInst)
+INSTRUCTION_SIMPLIFICATION(TypeValueInst)
+INSTRUCTION_SIMPLIFICATION(UncheckedEnumDataInst)
+INSTRUCTION_SIMPLIFICATION(WitnessMethodInst)
+INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(AllocStackInst)
+INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(UnconditionalCheckedCastInst)
+INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(ApplyInst)
+INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(TryApplyInst)
+
+#undef INSTRUCTION_SIMPLIFICATION
+#undef INSTRUCTION_SIMPLIFICATION_WITH_LEGACY