libswift: improve and simplify pass invocation

* unify FunctionPassContext and InstructionPassContext
* add a modification API: PassContext.setOperand
* automatic invalidation notifications when the SIL is modified

Author: eeckstein

include/swift/SIL/SILBridging.h

@@ -191,6 +191,8 @@ OptionalBridgedInstruction SILInstruction_next(BridgedInstruction inst);
 OptionalBridgedInstruction SILInstruction_previous(BridgedInstruction inst);
 BridgedBasicBlock SILInstruction_getParent(BridgedInstruction inst);
 BridgedArrayRef SILInstruction_getOperands(BridgedInstruction inst);
+void SILInstruction_setOperand(BridgedInstruction inst, SwiftInt index,
+                               BridgedValue value);
 BridgedLocation SILInstruction_getLocation(BridgedInstruction inst);
 BridgedMemoryBehavior SILInstruction_getMemBehavior(BridgedInstruction inst);
 

include/swift/SILOptimizer/OptimizerBridging.h

@@ -52,8 +52,9 @@ void SILPassManager_registerFunctionPass(BridgedStringRef name,
 void SILCombine_registerInstructionPass(BridgedStringRef name,
                                         BridgedInstructionPassRunFn runFn);
 
-BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context,
-                                                  BridgedFunction function);
+SwiftInt PassContext_isSwift51RuntimeAvailable(BridgedPassContext context);
+
+BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context);
 
 BridgedMemoryBehavior AliasAnalysis_getMemBehavior(BridgedAliasAnalysis aa,
                                                    BridgedInstruction inst,

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -48,19 +48,28 @@ void executePassPipelinePlan(SILModule *SM, const SILPassPipelinePlan &plan,
 class LibswiftPassInvocation {
   /// Backlink to the pass manager.
   SILPassManager *passManager;
-  
+
+  /// The currently optimized function.
+  SILFunction *function = nullptr;
+
   /// Non-null if this is an instruction pass, invoked from SILCombine.
-  SILCombiner *silCombiner;
+  SILCombiner *silCombiner = nullptr;
 
   /// All slabs, allocated by the pass.
   SILModule::SlabList allocatedSlabs;
 
 public:
-  LibswiftPassInvocation(SILPassManager *passManager, SILCombiner *silCombiner) :
-    passManager(passManager), silCombiner(silCombiner) {}
+  LibswiftPassInvocation(SILPassManager *passManager, SILFunction *function,
+                         SILCombiner *silCombiner) :
+    passManager(passManager), function(function), silCombiner(silCombiner) {}
+
+  LibswiftPassInvocation(SILPassManager *passManager) :
+    passManager(passManager) {}
 
   SILPassManager *getPassManager() const { return passManager; }
 
+  SILFunction *getFunction() const { return function; }
+
   FixedSizeSlab *allocSlab(FixedSizeSlab *afterSlab);
 
   FixedSizeSlab *freeSlab(FixedSizeSlab *slab);
@@ -71,6 +80,9 @@ class LibswiftPassInvocation {
   /// Called by the pass when changes are made to the SIL.
   void notifyChanges(SILAnalysis::InvalidationKind invalidationKind);
 
+  /// Called by the pass manager before the pass starts running.
+  void startPassRun(SILFunction *function);
+
   /// Called by the pass manager when the pass has finished.
   void finishedPassRun();
 };

lib/SIL/Utils/SILBridging.cpp

@@ -357,6 +357,11 @@ BridgedArrayRef SILInstruction_getOperands(BridgedInstruction inst) {
   return {(const unsigned char *)operands.data(), operands.size()};
 }
 
+void SILInstruction_setOperand(BridgedInstruction inst, SwiftInt index,
+                               BridgedValue value) {
+  castToInst(inst)->setOperand((unsigned)index, castToSILValue(value));
+}
+
 BridgedLocation SILInstruction_getLocation(BridgedInstruction inst) {
   SILDebugLocation loc = castToInst(inst)->getDebugLocation();
   return *reinterpret_cast<BridgedLocation *>(&loc);

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -322,7 +322,7 @@ void swift::executePassPipelinePlan(SILModule *SM,
 SILPassManager::SILPassManager(SILModule *M, bool isMandatory,
                                irgen::IRGenModule *IRMod)
     : Mod(M), IRMod(IRMod),
-      libswiftPassInvocation(this, /*SILCombiner*/ nullptr),
+      libswiftPassInvocation(this),
       isMandatory(isMandatory), deserializationNotificationHandler(nullptr) {
 #define ANALYSIS(NAME) \
   Analyses.push_back(create##NAME##Analysis(Mod));
@@ -469,7 +469,9 @@ void SILPassManager::runPassOnFunction(unsigned TransIdx, SILFunction *F) {
 
   assert(changeNotifications == SILAnalysis::InvalidationKind::Nothing
          && "change notifications not cleared");
-  
+
+  libswiftPassInvocation.startPassRun(F);
+
   // Run it!
   SFT->run();
 
@@ -1100,8 +1102,14 @@ FixedSizeSlab *LibswiftPassInvocation::freeSlab(FixedSizeSlab *slab) {
   return prev;
 }
 
+void LibswiftPassInvocation::startPassRun(SILFunction *function) {
+  assert(!this->function && "a pass is already running");
+  this->function = function;
+}
+
 void LibswiftPassInvocation::finishedPassRun() {
   assert(allocatedSlabs.empty() && "StackList is leaking slabs");
+  function = nullptr;
 }
 
 //===----------------------------------------------------------------------===//
@@ -1166,10 +1174,17 @@ void PassContext_eraseInstruction(BridgedPassContext passContext,
   castToPassInvocation(passContext)->eraseInstruction(castToInst(inst));
 }
 
-BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context,
-                                                  BridgedFunction function) {
+SwiftInt PassContext_isSwift51RuntimeAvailable(BridgedPassContext context) {
   SILPassManager *pm = castToPassInvocation(context)->getPassManager();
-  return {pm->getAnalysis<AliasAnalysis>(castToFunction(function))};
+  ASTContext &ctxt = pm->getModule()->getASTContext();
+  return AvailabilityContext::forDeploymentTarget(ctxt).
+           isContainedIn(ctxt.getSwift51Availability());
+}
+
+BridgedAliasAnalysis PassContext_getAliasAnalysis(BridgedPassContext context) {
+  LibswiftPassInvocation *invocation = castToPassInvocation(context);
+  SILPassManager *pm = invocation->getPassManager();
+  return {pm->getAnalysis<AliasAnalysis>(invocation->getFunction())};
 }
 
 BridgedCalleeAnalysis PassContext_getCalleeAnalysis(BridgedPassContext context) {

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -158,7 +158,8 @@ class SILCombiner :
             [&](SILInstruction *I) { eraseInstFromFunction(*I); }),
         deBlocks(&B.getFunction()),
         ownershipFixupContext(getInstModCallbacks(), deBlocks),
-        libswiftPassInvocation(parentTransform->getPassManager(), this) {}
+        libswiftPassInvocation(parentTransform->getPassManager(),
+                               parentTransform->getFunction(), this) {}
 
   bool runOnFunction(SILFunction &F);
 

libswift/Sources/Optimizer/FunctionPasses/MergeCondFails.swift

@@ -29,7 +29,7 @@ private func hasOverflowConditionOperand(_ cfi: CondFailInst) -> Bool {
 /// write in between them.
 /// This pass merges cond_fail instructions by building the disjunction of
 /// their operands.
-private func runMergeCondFails(function: Function, context: FunctionPassContext) {
+private func runMergeCondFails(function: Function, context: PassContext) {
 
   // Merge cond_fail instructions if there is no side-effect or read in
   // between them.
@@ -59,7 +59,7 @@ private func runMergeCondFails(function: Function, context: FunctionPassContext)
 /// Try to merge the cond_fail instructions. Returns true if any could
 /// be merge.
 private func mergeCondFails(_ condFailToMerge: inout StackList<CondFailInst>,
-                            context: FunctionPassContext) {
+                            context: PassContext) {
   guard let lastCFI = condFailToMerge.last else {
     return
   }

libswift/Sources/Optimizer/FunctionPasses/SILPrinter.swift

@@ -14,7 +14,7 @@ import SIL
 
 let silPrinterPass = FunctionPass(name: "sil-printer", runSILPrinter)
 
-func runSILPrinter(function: Function, context: FunctionPassContext) {
+func runSILPrinter(function: Function, context: PassContext) {
   print("run SILPrinter on function: \(function.name)")
 
   for (bbIdx, block) in function.blocks.enumerated() {

libswift/Sources/Optimizer/InstructionPasses/SimplifyGlobalValue.swift

@@ -14,7 +14,7 @@ import SIL
 
 let simplifyGlobalValuePass = InstructionPass<GlobalValueInst>(
   name: "simplify-global_value", {
-  (globalValue: GlobalValueInst, context: InstructionPassContext) in
+  (globalValue: GlobalValueInst, context: PassContext) in
 
   var users = StackList<Instruction>(context)
   if checkUsers(of: globalValue, users: &users) {

libswift/Sources/Optimizer/PassManager/PassUtils.swift

@@ -18,107 +18,96 @@ public typealias BridgedFunctionPassCtxt =
 public typealias BridgedInstructionPassCtxt =
   OptimizerBridging.BridgedInstructionPassCtxt
 
-struct FunctionPassContext {
+struct PassContext {
 
   fileprivate let passContext: BridgedPassContext
-  fileprivate let function: Function
 
-  func erase(instruction: Instruction) {
-    PassContext_eraseInstruction(passContext, instruction.bridged)
+  var isSwift51RuntimeAvailable: Bool {
+    PassContext_isSwift51RuntimeAvailable(passContext) != 0
   }
 
-  private func notifyChanges(_ kind: ChangeNotificationKind) {
-    PassContext_notifyChanges(passContext, kind)
-  }
-
   var aliasAnalysis: AliasAnalysis {
-    let bridgedAA = PassContext_getAliasAnalysis(passContext, function.bridged)
+    let bridgedAA = PassContext_getAliasAnalysis(passContext)
     return AliasAnalysis(bridged: bridgedAA)
   }
 
   var calleeAnalysis: CalleeAnalysis {
     let bridgeCA = PassContext_getCalleeAnalysis(passContext)
     return CalleeAnalysis(bridged: bridgeCA)
   }
+
+  func erase(instruction: Instruction) {
+    if instruction is FullApplySite {
+      PassContext_notifyChanges(passContext, callsChanged)
+    }
+    if instruction is TermInst {
+      PassContext_notifyChanges(passContext, branchesChanged)
+    }
+    PassContext_notifyChanges(passContext, instructionsChanged)
+
+    PassContext_eraseInstruction(passContext, instruction.bridged)
+  }
+  
+  func setOperand(of instruction: Instruction, at index : Int, to value: Value) {
+    if instruction is FullApplySite && index == ApplyOperands.calleeOperandIndex {
+      PassContext_notifyChanges(passContext, callsChanged)
+    }
+    PassContext_notifyChanges(passContext, instructionsChanged)
+
+    SILInstruction_setOperand(instruction.bridged, index, value.bridged)
+  }
 }
 
 struct FunctionPass {
 
   let name: String
-  let runFunction: (Function, FunctionPassContext) -> ()
+  let runFunction: (Function, PassContext) -> ()
 
   public init(name: String,
-              _ runFunction: @escaping (Function, FunctionPassContext) -> ()) {
+              _ runFunction: @escaping (Function, PassContext) -> ()) {
     self.name = name
     self.runFunction = runFunction
   }
 
   func run(_ bridgedCtxt: BridgedFunctionPassCtxt) {
     let function = bridgedCtxt.function.function
-    let context = FunctionPassContext(passContext: bridgedCtxt.passContext,
-                                      function: function)
+    let context = PassContext(passContext: bridgedCtxt.passContext)
     runFunction(function, context)
   }
 }
 
-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) -> ()
+  let runFunction: (InstType, PassContext) -> ()
 
-  public init(name: String, _ runFunction: @escaping (InstType, InstructionPassContext) -> ()) {
+  public init(name: String,
+              _ runFunction: @escaping (InstType, PassContext) -> ()) {
     self.name = name
     self.runFunction = runFunction
   }
 
   func run(_ bridgedCtxt: BridgedInstructionPassCtxt) {
     let inst = bridgedCtxt.instruction.getAs(InstType.self)
-    let context = InstructionPassContext(passContext: bridgedCtxt.passContext)
+    let context = PassContext(passContext: bridgedCtxt.passContext)
     runFunction(inst, context)
   }
 }
 
 extension StackList {
-  init(_ context: FunctionPassContext) {
-    self.init(context: context.passContext)
-  }
-  
-  init(_ context: InstructionPassContext) {
+  init(_ context: PassContext) {
     self.init(context: context.passContext)
   }
 }
 
 extension Builder {
   init(at insPnt: Instruction, location: Location,
-       _ context: FunctionPassContext) {
-    self.init(insertionPoint: insPnt, location: location,
-              passContext: context.passContext)
-  }
-
-  init(at insPnt: Instruction, _ context: FunctionPassContext) {
-    self.init(insertionPoint: insPnt, location: insPnt.location,
-              passContext: context.passContext)
-  }
-
-  init(at insPnt: Instruction, location: Location,
-       _ context: InstructionPassContext) {
+       _ context: PassContext) {
     self.init(insertionPoint: insPnt, location: location,
               passContext: context.passContext)
   }
 
-  init(at insPnt: Instruction, _ context: InstructionPassContext) {
+  init(at insPnt: Instruction, _ context: PassContext) {
     self.init(insertionPoint: insPnt, location: insPnt.location,
               passContext: context.passContext)
   }

libswift/Sources/SIL/ApplySite.swift

@@ -10,24 +10,28 @@
 //
 //===----------------------------------------------------------------------===//
 
+public struct ApplyOperands {
+  public static let calleeOperandIndex: Int = 0
+  public static let firstArgumentIndex = 1
+}
+
 public protocol ApplySite : AnyObject {
   var operands: OperandArray { get }
   var numArguments: Int { get }
 }
 
-private let firstArgumentIndex = 1
-
 extension ApplySite {
-  public var callee: Value { operands[0].value }
+  public var callee: Value { operands[ApplyOperands.calleeOperandIndex].value }
 
   public func argumentIndex(of operand: Operand) -> Int? {
     let opIdx = operand.index
-    if opIdx >= firstArgumentIndex &&
-       opIdx <= firstArgumentIndex + numArguments {
-      return opIdx - firstArgumentIndex
+    if opIdx >= ApplyOperands.firstArgumentIndex &&
+       opIdx <= ApplyOperands.firstArgumentIndex + numArguments {
+      return opIdx - ApplyOperands.firstArgumentIndex
     }
     return nil
   }
+
 }
 
 public protocol FullApplySite : ApplySite {