Merge main 2023-02-11

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -8,10 +8,12 @@
 
 swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
+  CleanupDebugSteps.swift
   ComputeEscapeEffects.swift
   ComputeSideEffects.swift
   ObjCBridgingOptimization.swift
   MergeCondFails.swift
   ReleaseDevirtualizer.swift
+  SimplificationPasses.swift
   StackPromotion.swift
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CleanupDebugSteps.swift

@@ -0,0 +1,83 @@
+//===--- SimplificationPasses.swift ----------------------------------------==//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+/// Removes redundant `debug_step` instructions.
+/// If a `debug_step` has the same debug location as a previous or succeeding instruction
+/// it is removed. It's just important that there is at least one instruction for a
+/// certain debug location so that single stepping on that location will work.
+let cleanupDebugStepsPass = FunctionPass(name: "cleanup-debug-steps") {
+  (function: Function, context: FunctionPassContext) in
+
+  for block in function.blocks {
+    cleanupDebugSteps(in: block, context)
+  }
+}
+
+private func cleanupDebugSteps(in block: BasicBlock, _ context: FunctionPassContext) {
+  var lastInstWithSameLocation: Instruction?
+
+  for inst in block.instructions {
+    if !inst.location.isDebugSteppable {
+      if inst is DebugStepInst && !inst.location.isDebugSteppable {
+        // First case: the instruction which is replaced by the debug_step didn't have a valid
+        // location itself. Then we don't need the debug_step either.
+        context.erase(instruction: inst)
+      }
+      continue
+    }
+
+    if let li = lastInstWithSameLocation,
+       !inst.location.hasSameSourceLocation(as: li.location) {
+      lastInstWithSameLocation = nil
+    }
+
+    // Only instructions which are really compiled down to some machine instructions can be
+    // single stepped on.
+    if !inst.producesMachineCode {
+      continue
+    }
+
+    if let li = lastInstWithSameLocation {
+      if inst is DebugStepInst {
+
+        // Second case:
+        //   %li = some_instruction, loc "l"
+        //   debug_step, loc "l"                // current inst -> erase
+        context.erase(instruction: inst)
+        continue
+      } else if li is DebugStepInst {
+
+        // Third case:
+        //   debug_step, loc "l"                // li -> erase
+        //   %inst = some_instruction, loc "l"  // current inst
+        context.erase(instruction: li)
+      }
+    }
+    lastInstWithSameLocation = inst
+  }
+}
+
+private extension Instruction {
+  var producesMachineCode: Bool {
+    switch self {
+    // We could include more instructions here.
+    // In worst case a debug_step instruction remains in the code although it's not needed.
+    // This is harmless.
+    case is DebugStepInst, is ApplySite, is LoadInst, is StoreInst, is TermInst:
+      return location.isDebugSteppable
+    default:
+      return false
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/SimplificationPasses.swift

@@ -0,0 +1,137 @@
+//===--- SimplificationPasses.swift ----------------------------------------==//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+//===--------------------------------------------------------------------===//
+//                        Instruction protocols
+//===--------------------------------------------------------------------===//
+
+/// Instructions which can be simplified at all optimization levels
+protocol Simplifyable : Instruction {
+  func simplify(_ context: SimplifyContext)
+}
+
+/// Instructions which can be simplified at -Onone
+protocol OnoneSimplifyable : Simplifyable {
+}
+
+/// Instructions which can only be simplified at the end of the -Onone pipeline
+protocol LateOnoneSimplifyable : Instruction {
+  func simplifyLate(_ context: SimplifyContext)
+}
+
+//===--------------------------------------------------------------------===//
+//                        Simplification passes
+//===--------------------------------------------------------------------===//
+
+let ononeSimplificationPass = FunctionPass(name: "onone-simplification") {
+  (function: Function, context: FunctionPassContext) in
+
+  runSimplification(on: function, context, preserveDebugInfo: true) {
+    if let i = $0 as? OnoneSimplifyable {
+      i.simplify($1)
+    }
+  }
+}
+
+let simplificationPass = FunctionPass(name: "simplification") {
+  (function: Function, context: FunctionPassContext) in
+
+  runSimplification(on: function, context, preserveDebugInfo: false) {
+    if let i = $0 as? Simplifyable {
+      i.simplify($1)
+    }
+  }
+}
+
+let lateOnoneSimplificationPass = FunctionPass(name: "late-onone-simplification") {
+  (function: Function, context: FunctionPassContext) in
+
+  runSimplification(on: function, context, preserveDebugInfo: true) {
+    if let i = $0 as? LateOnoneSimplifyable {
+      i.simplifyLate($1)
+    } else if let i = $0 as? OnoneSimplifyable {
+      i.simplify($1)
+    }
+  }
+}
+
+//===--------------------------------------------------------------------===//
+//                         Pass implementation
+//===--------------------------------------------------------------------===//
+
+
+private func runSimplification(on function: Function, _ context: FunctionPassContext,
+                               preserveDebugInfo: Bool,
+                               _ simplify: (Instruction, SimplifyContext) -> ()) {
+  var worklist = InstructionWorklist(context)
+  defer { worklist.deinitialize() }
+
+  let simplifyCtxt = context.createSimplifyContext(preserveDebugInfo: preserveDebugInfo,
+                                                   notifyInstructionChanged: {
+    worklist.pushIfNotVisited($0)
+  })
+
+  // Push in reverse order so that popping from the tail of the worklist visits instruction in forward order again.
+  worklist.pushIfNotVisited(contentsOf: function.reversedInstructions)
+
+  // Run multiple iterations because cleanupDeadCode can add new candidates to the worklist.
+  repeat {
+
+    // The core worklist-loop.
+    while let instruction = worklist.popAndForget() {
+      if instruction.isDeleted {
+        continue
+      }
+      if !context.options.enableSimplification(for: instruction) {
+        continue
+      }
+      if !context.continueWithNextSubpassRun(for: instruction) {
+        return
+      }
+      simplify(instruction, simplifyCtxt)
+    }
+
+    cleanupDeadInstructions(in: function, preserveDebugInfo, context)
+    cleanupDeadBlocks(in: function, pushNewCandidatesTo: &worklist, context)
+
+  } while !worklist.isEmpty
+
+  if context.needFixStackNesting {
+    function.fixStackNesting(context)
+  }
+}
+
+private func cleanupDeadInstructions(in function: Function,
+                                     _ preserveDebugInfo: Bool,
+                                     _ context: FunctionPassContext) {
+  if preserveDebugInfo {
+    context.removeTriviallyDeadInstructionsPreservingDebugInfo(in: function)
+  } else {
+    context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
+  }
+}
+
+private func cleanupDeadBlocks(in function: Function,
+                               pushNewCandidatesTo worklist: inout InstructionWorklist,
+                               _ context: FunctionPassContext) {
+  if context.removeDeadBlocks(in: function) {
+    // After deleting dead blocks their (still alive) successor blocks may become eligible for block merging.
+    // Therefore we re-run simplification for all branch instructions.
+    for block in function.blocks.reversed() {
+      if let bi = block.terminator as? BranchInst {
+        worklist.pushIfNotVisited(bi)
+      }
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -7,6 +7,12 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
+  SimplifyApply.swift
   SimplifyBeginCOWMutation.swift
+  SimplifyBranch.swift
+  SimplifyBuiltin.swift
+  SimplifyCondBranch.swift
   SimplifyGlobalValue.swift
-  SimplifyStrongRetainRelease.swift)
+  SimplifyStrongRetainRelease.swift
+  SimplifyStructExtract.swift
+  SimplifyUncheckedEnumData.swift)

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyApply.swift

@@ -0,0 +1,61 @@
+//===--- SimplifyApply.swift ----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension ApplyInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    tryReplaceTrivialApplyOfPartialApply(context)
+  }
+}
+
+private extension ApplyInst {
+  func tryReplaceTrivialApplyOfPartialApply(_ context: SimplifyContext) {
+    guard let pa = callee as? PartialApplyInst else {
+      return
+    }
+
+    if pa.referencedFunction == nil {
+      return
+    }
+
+    // Currently we don't handle generic closures. For Onone this is good enough.
+    // TODO: handle it once we replace the SILCombine simplification with this.
+    if !allArgumentsAreTrivial(arguments) {
+      return
+    }
+
+    if !allArgumentsAreTrivial(pa.arguments) {
+      return
+    }
+
+    if !substitutionMap.isEmpty {
+      return
+    }
+
+    let allArgs = Array<Value>(arguments) + Array<Value>(pa.arguments)
+    let builder = Builder(before: self, context)
+    let newApply = builder.createApply(function: pa.callee, pa.substitutionMap, arguments: allArgs,
+                                       isNonThrowing: isNonThrowing, isNonAsync: isNonAsync,
+                                       specializationInfo: specializationInfo)
+    uses.replaceAll(with: newApply, context)
+    context.erase(instruction: self)
+
+    if context.tryDeleteDeadClosure(closure: pa) {
+      context.notifyInvalidatedStackNesting()
+    }
+  }
+}
+
+private func allArgumentsAreTrivial(_ args: LazyMapSequence<OperandArray, Value>) -> Bool {
+  return !args.contains { !$0.hasTrivialType }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginCOWMutation.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-extension BeginCOWMutationInst : SILCombineSimplifyable {
+extension BeginCOWMutationInst : Simplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
 
     /// The buffer of an empty Array/Set/Dictionary singleton is known to be not