Merge pull request #60924 from eeckstein/swift-sil-infrastructure

Some Swift SIL infrastructure additions and improvements

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -109,13 +109,6 @@ struct FunctionUses {
   // The use-list head for each function.
   private var uses: [Function: FirstUse] = [:]
 
-  init() {
-    // Already start with a reasonable big capacity to reduce the number of
-    // re-allocations when appending to the data structures.
-    useStorage.reserveCapacity(128)
-    uses.reserveCapacity(64)
-  }
-
   /// Returns the use-list of `function`.
   ///
   /// Note that `collect` must be called before `getUses` can be used.
@@ -125,7 +118,12 @@ struct FunctionUses {
 
   /// Collects all uses of all function in the module.
   mutating func collect(context: ModulePassContext) {
-  
+
+    // Already start with a reasonable big capacity to reduce the number of
+    // re-allocations when appending to the data structures.
+    useStorage.reserveCapacity(128)
+    uses.reserveCapacity(64)
+
     // Mark all functions, which are referenced from tables, to have "unknown" uses.
 
     for vTable in context.vTables {

SwiftCompilerSources/Sources/Optimizer/PassManager/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   ModulePassContext.swift
+  Options.swift
   Passes.swift
   PassContext.swift
   PassRegistration.swift)

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -91,6 +91,8 @@ struct ModulePassContext {
     DefaultWitnessTableList(first: PassContext_firstDefaultWitnessTableInModule(_bridged).table)
   }
 
+  var options: Options { Options(_bridged: _bridged) }
+
   /// Run a closure with a `PassContext` for a function, which allows to modify that function.
   ///
   /// Only a single `transform` can be alive at the same time, i.e. it's not allowed to nest

SwiftCompilerSources/Sources/Optimizer/PassManager/Options.swift

@@ -0,0 +1,17 @@
+//===--- Options.swift ----------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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 OptimizerBridging
+
+struct Options {
+  let _bridged: BridgedPassContext
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassContext.swift

@@ -22,6 +22,8 @@ struct PassContext {
 
   let _bridged: BridgedPassContext
 
+  var options: Options { Options(_bridged: _bridged) }
+
   func continueWithNextSubpassRun(for inst: Instruction? = nil) -> Bool {
     let bridgedInst = OptionalBridgedInstruction(obj: inst?.bridged.obj)
     return PassContext_continueWithNextSubpassRun(_bridged, bridgedInst) != 0

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -61,34 +61,29 @@ private func printAccessInfo(address: Value) {
 
   var apw = AccessPathWalker()
   let (ap, scope) = apw.getAccessPathWithScope(of: address)
-  if let scope = scope {
-    switch scope {
-    case let .scope(ba):
-      print("  Scope: \(ba)")
-    case .base(_):
-      print("  Scope: base")
-    }
+  switch scope {
+  case let .scope(ba):
+    print("  Scope: \(ba)")
+  case .base(_):
+    print("  Scope: base")
   }
 
-  if let ap = ap {
-    print("  Base: \(ap.base)")
-    print("  Path: \"\(ap.projectionPath)\"")
+  print("  Base: \(ap.base)")
+  print("  Path: \"\(ap.projectionPath)\"")
 
-    var arw = AccessStoragePathVisitor()
-    if !arw.visitAccessStorageRoots(of: ap) {
-      print("   no Storage paths")
-    }
+  var arw = AccessStoragePathVisitor()
+  if !arw.visitAccessStorageRoots(of: ap) {
+    print("   no Storage paths")
   }
 }
 
 private func checkAliasInfo(forArgumentsOf apply: ApplyInst, expectDistinct: Bool) {
   let address1 = apply.arguments[0]
   let address2 = apply.arguments[1]
   var apw = AccessPathWalker()
-  guard let path1 = apw.getAccessPath(of: address1),
-        let path2 = apw.getAccessPath(of: address2) else {
-    return
-  }
+  let path1 = apw.getAccessPath(of: address1)
+  let path2 = apw.getAccessPath(of: address2)
+
   if path1.isDistinct(from: path2) != expectDistinct {
     print("wrong isDistinct result of \(apply)")
   } else if path2.isDistinct(from: path1) != expectDistinct {

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -73,7 +73,11 @@ enum AccessBase : CustomStringConvertible, Hashable {
   /// An address which is derived from a `Builtin.RawPointer`.
   case pointer(PointerToAddressInst)
 
-  init?(baseAddress: Value) {
+  /// The access base is some SIL pattern which does not fit into any other case.
+  /// This should be a very rare situation.
+  case unidentified
+
+  init(baseAddress: Value) {
     switch baseAddress {
     case let rea as RefElementAddrInst   : self = .class(rea)
     case let rta as RefTailAddrInst      : self = .tail(rta)
@@ -85,15 +89,16 @@ enum AccessBase : CustomStringConvertible, Hashable {
       if let ba = mvr.instruction as? BeginApplyInst, baseAddress.type.isAddress {
         self = .yield(ba)
       } else {
-        return nil
+        self = .unidentified
       }
     default:
-      return nil
+      self = .unidentified
     }
   }
 
   var description: String {
     switch self {
+      case .unidentified:      return "?"
       case .box(let pbi):      return "box - \(pbi)"
       case .stack(let asi):    return "stack - \(asi)"
       case .global(let gl):    return "global - @\(gl.name)"
@@ -110,7 +115,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     switch self {
       case .class, .tail:
         return true
-      case .box, .stack, .global, .argument, .yield, .pointer:
+      case .box, .stack, .global, .argument, .yield, .pointer, .unidentified:
         return false
     }
   }
@@ -121,7 +126,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
       case .box(let pbi):      return pbi.operand
       case .class(let rea):    return rea.operand
       case .tail(let rta):     return rta.operand
-      case .stack, .global, .argument, .yield, .pointer:
+      case .stack, .global, .argument, .yield, .pointer, .unidentified:
         return nil
     }
   }
@@ -130,7 +135,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     switch self {
       case .class(let rea):    return rea.fieldIsLet
       case .global(let g):     return g.isLet
-      case .box, .stack, .tail, .argument, .yield, .pointer:
+      case .box, .stack, .tail, .argument, .yield, .pointer, .unidentified:
         return false
     }
   }
@@ -142,7 +147,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
       case .class(let rea):    return rea.operand is AllocRefInstBase
       case .tail(let rta):     return rta.operand is AllocRefInstBase
       case .stack:             return true
-      case .global, .argument, .yield, .pointer:
+      case .global, .argument, .yield, .pointer, .unidentified:
         return false
     }
   }
@@ -152,7 +157,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     switch self {
       case .box, .class, .tail, .stack, .global:
         return true
-      case .argument, .yield, .pointer:
+      case .argument, .yield, .pointer, .unidentified:
         return false
     }
   }
@@ -174,7 +179,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     }
 
     func argIsDistinct(_ arg: FunctionArgument, from other: AccessBase) -> Bool {
-      if arg.isExclusiveIndirectParameter {
+      if arg.convention.isExclusiveIndirect {
         // Exclusive indirect arguments cannot alias with an address for which we know that it
         // is not derived from that argument (which might be the case for `pointer` and `yield`).
         return other.hasKnownStorageKind
@@ -199,7 +204,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     case (.tail(let rta), .tail(let otherRta)):
       return isDifferentAllocation(rta.operand, otherRta.operand)
     case (.argument(let arg), .argument(let otherArg)):
-      return (arg.isExclusiveIndirectParameter || otherArg.isExclusiveIndirectParameter) && arg != otherArg
+      return (arg.convention.isExclusiveIndirect || otherArg.convention.isExclusiveIndirect) && arg != otherArg
 
     // Handle arguments vs non-arguments
     case (.argument(let arg), _):
@@ -224,6 +229,10 @@ struct AccessPath : CustomStringConvertible {
   /// address projections only
   let projectionPath: SmallProjectionPath
 
+  static func unidentified() -> AccessPath {
+    return AccessPath(base: .unidentified, projectionPath: SmallProjectionPath())
+  }
+
   var description: String {
     "\(projectionPath): \(base)"
   }
@@ -362,46 +371,46 @@ enum EnclosingScope {
 /// of the access (the base address and the address projections to the accessed fields) and
 /// the innermost enclosing scope (`begin_access`).
 struct AccessPathWalker {
-  mutating func getAccessPath(of address: Value) -> AccessPath? {
+  mutating func getAccessPath(of address: Value) -> AccessPath {
     assert(address.type.isAddress, "Expected address")
     walker.start()
     if walker.walkUp(address: address, path: Walker.Path()) == .abortWalk {
-      return nil
+      assert(walker.result.base == .unidentified,
+             "shouldn't have set an access base in an aborted walk")
     }
     return walker.result
   }
 
-  mutating func getAccessPathWithScope(of address: Value) -> (AccessPath?, EnclosingScope?) {
+  mutating func getAccessPathWithScope(of address: Value) -> (AccessPath, EnclosingScope) {
     let ap = getAccessPath(of: address)
     return (ap, walker.scope)
   }
 
-  mutating func getAccessBase(of address: Value) -> AccessBase? {
-    getAccessPath(of: address)?.base
+  mutating func getAccessBase(of address: Value) -> AccessBase {
+    getAccessPath(of: address).base
   }
 
-  mutating func getAccessScope(of address: Value) -> EnclosingScope? {
+  mutating func getAccessScope(of address: Value) -> EnclosingScope {
     getAccessPathWithScope(of: address).1
   }
 
   private var walker = Walker()
 
   private struct Walker : AddressUseDefWalker {
-    private(set) var result: AccessPath? = nil
+    private(set) var result = AccessPath.unidentified()
     private var foundBeginAccess: BeginAccessInst? = nil
     private var pointerId = PointerIdentification()
 
-    var scope: EnclosingScope? {
+    var scope: EnclosingScope {
       if let ba = foundBeginAccess {
         return .scope(ba)
       } else {
-        guard let accessPath = result else { return nil }
-        return .base(accessPath.base)
+        return .base(result.base)
       }
     }
 
     mutating func start() {
-      result = nil
+      result = .unidentified()
       foundBeginAccess = nil
     }
 
@@ -435,7 +444,7 @@ struct AccessPathWalker {
     }
 
     mutating func rootDef(address: Value, path: Path) -> WalkResult {
-      assert(result == nil, "rootDef should only called once")
+      assert(result.base == .unidentified, "rootDef should only called once")
       // Try identifying the address a pointer originates from
       if let p2ai = address as? PointerToAddressInst {
         if let originatingAddr = pointerId.getOriginatingAddress(of: p2ai) {
@@ -446,15 +455,9 @@ struct AccessPathWalker {
         }
       }
 
-      // If this is a base then we're done
-      if let base = AccessBase(baseAddress: address) {
-        self.result = AccessPath(base: base, projectionPath: path.projectionPath)
-        return .continueWalk
-      }
-
-      // The base is unidentified
-      self.result = nil
-      return .abortWalk
+      let base = AccessBase(baseAddress: address)
+      self.result = AccessPath(base: base, projectionPath: path.projectionPath)
+      return .continueWalk
     }
 
     mutating func walkUp(address: Value, path: Path) -> WalkResult {
@@ -464,7 +467,6 @@ struct AccessPathWalker {
       } else if path.indexAddr && !canBeOperandOfIndexAddr(address) {
         // An `index_addr` instruction cannot be derived from an address
         // projection. Bail out
-        self.result = nil
         return .abortWalk
       } else if let ba = address as? BeginAccessInst, foundBeginAccess == nil {
         foundBeginAccess = ba
@@ -474,6 +476,27 @@ struct AccessPathWalker {
   }
 }
 
+extension Value {
+  // Convenient properties to avoid instantiating an explicit AccessPathWalker.
+  //
+  // Although an AccessPathWalker is created for each call of these properties,
+  // it's very unlikely that this will end up in memory allocations.
+  // Only in the rare case of `pointer_to_address` -> `address_to_pointer` pairs, which
+  // go through phi-arguments, the AccessPathWalker will allocate memnory in its cache.
+
+  /// Computes the access base of this address value.
+  var accessBase: AccessBase {
+    var apWalker = AccessPathWalker()
+    return apWalker.getAccessBase(of: self)
+  }
+  
+  /// Computes the enclosing access scope of this address value.
+  var accessScope: EnclosingScope {
+    var apWalker = AccessPathWalker()
+    return apWalker.getAccessScope(of: self)
+  }
+}
+
 /// A ValueUseDef walker that identifies which values a reference of an access path might
 /// originate from.
 protocol AccessStoragePathWalker : ValueUseDefWalker where Path == SmallProjectionPath {
@@ -496,7 +519,7 @@ extension AccessStoragePathWalker {
         return walkUp(value: rea.operand, path: path.push(.classField, index: rea.fieldIndex)) != .abortWalk
       case .tail(let rta):
         return walkUp(value: rta.operand, path: path.push(.tailElements, index: 0)) != .abortWalk
-      case .stack, .global, .argument, .yield, .pointer:
+      case .stack, .global, .argument, .yield, .pointer, .unidentified:
         return false
     }
   }

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeInfo.swift

@@ -734,7 +734,7 @@ fileprivate struct EscapeInfoWalker<V: EscapeInfoVisitor> : ValueDefUseWalker,
     case is AllocStackInst:
       return cachedWalkDown(addressOrValue: def, path: path.with(knownType: nil))
     case let arg as FunctionArgument:
-      if canIgnoreForLoadOrArgument(path) && arg.isExclusiveIndirectParameter && !path.followStores {
+      if canIgnoreForLoadOrArgument(path) && arg.convention.isExclusiveIndirect && !path.followStores {
         return cachedWalkDown(addressOrValue: def, path: path.with(knownType: nil))
       } else {
         return isEscaping