Merge remote-tracking branch 'apple/main' into katei/merge-main-2022-11-03

Author: kateinoigakukun

CMakeLists.txt

@@ -116,7 +116,7 @@ endif()
 if(SWIFT_HOST_VARIANT_ARCH)
   set(SWIFT_HOST_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}")
 else()
-  if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64|amd64")
     set(SWIFT_HOST_VARIANT_ARCH_default "x86_64")
   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|ARM64|arm64")
     if(SWIFT_HOST_VARIANT_SDK_default STREQUAL OSX)

README.md

@@ -45,7 +45,6 @@ to track the status of our builds, please refer to our [GitHub Actions page](htt
 |**[Ubuntu 20.04](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/wasm32_ubuntu_20.04.json)** | wasm32 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | ARMv7 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | AArch64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64)|
-|**[Windows 2019 (VS 2017)](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_windows_2019.json)** | x86_64 | [![Build Status](https://ci-external.swift.org/job/oss-swift-windows-x86_64/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-windows-x86_64)|
 |**[Windows 2019 (VS 2019)](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_windows_2019_VS2019.json)** | x86_64 | [![Build Status](https://ci-external.swift.org/job/oss-swift-windows-x86_64-vs2019/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-windows-x86_64-vs2019)|
 
 ## Welcome to Swift

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -60,4 +60,148 @@ struct AliasAnalysis {
     // Any other non-address value means: all addresses of any referenced class instances within the value.
     return SmallProjectionPath(.anyValueFields).push(.anyClassField).push(.anyValueFields)
   }
+  
+  static func register() {
+    AliasAnalysis_register(
+      // getMemEffectsFn
+      { (bridgedCtxt: BridgedPassContext, bridgedVal: BridgedValue, bridgedInst: BridgedInstruction) -> BridgedMemoryBehavior in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let inst = bridgedInst.instruction
+        let val = bridgedVal.value
+        let path = AliasAnalysis.getPtrOrAddressPath(for: val)
+        if let apply = inst as? ApplySite {
+          let effect = getMemoryEffect(of: apply, for: val, path: path, context)
+          switch (effect.read, effect.write) {
+            case (false, false): return NoneBehavior
+            case (true, false):  return MayReadBehavior
+            case (false, true):  return MayWriteBehavior
+            case (true, true):   return MayReadWriteBehavior
+          }
+        }
+        if val.at(path).isAddressEscaping(using: EscapesToInstructionVisitor(target: inst), context) {
+          return MayReadWriteBehavior
+        }
+        return NoneBehavior
+      },
+
+      // isObjReleasedFn
+      { (bridgedCtxt: BridgedPassContext, bridgedObj: BridgedValue, bridgedInst: BridgedInstruction) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let inst = bridgedInst.instruction
+        let obj = bridgedObj.value
+        let path = SmallProjectionPath(.anyValueFields)
+        if let apply = inst as? ApplySite {
+          let effect = getOwnershipEffect(of: apply, for: obj, path: path, context)
+          return effect.destroy
+        }
+        return obj.at(path).isEscaping(using: EscapesToInstructionVisitor(target: inst), context)
+      },
+
+      // isAddrVisibleFromObj
+      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+        let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
+
+        // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
+        // considered which are transitively visible from `bridgedObj`.
+        let anythingReachableFromObj = bridgedObj.value.at(SmallProjectionPath(.anything))
+        return addr.canAddressAlias(with: anythingReachableFromObj, context)
+      },
+
+      // canReferenceSameFieldFn
+      { (bridgedCtxt: BridgedPassContext, bridgedLhs: BridgedValue, bridgedRhs: BridgedValue) -> Bool in
+        let context = PassContext(_bridged: bridgedCtxt)
+
+        // If `lhs` or `rhs` is not an address, but an object, it means: check for alias of any class
+        // field address of the object.
+        let lhs = bridgedLhs.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedLhs.value))
+        let rhs = bridgedRhs.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedRhs.value))
+        return lhs.canAddressAlias(with: rhs, context)
+      }
+    )
+  }
+}
+
+private func getMemoryEffect(of apply: ApplySite, for address: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Memory {
+  let calleeAnalysis = context.calleeAnalysis
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: calleeAnalysis)
+  let memoryEffects: SideEffects.Memory
+
+  // First try to figure out to which argument(s) the address "escapes" to.
+  if let result = address.at(path).visitAddress(using: visitor, context) {
+    // The resulting effects are the argument effects to which `address` escapes to.
+    memoryEffects = result.memory
+  } else {
+    // `address` has unknown escapes. So we have to take the global effects of the called function(s).
+    memoryEffects = calleeAnalysis.getSideEffects(of: apply).memory
+  }
+  // Do some magic for `let` variables. Function calls cannot modify let variables.
+  // The only exception is that the let variable is directly passed to an indirect out of the
+  // apply.
+  // TODO: make this a more formal and verified approach.
+  if memoryEffects.write && address.accessBase.isLet && !address.isIndirectResult(of: apply) {
+    return SideEffects.Memory(read: memoryEffects.read, write: false)
+  }
+  return memoryEffects
+}
+
+private func getOwnershipEffect(of apply: ApplySite, for value: Value, path: SmallProjectionPath, _ context: PassContext) -> SideEffects.Ownership {
+  let visitor = SideEffectsVisitor(apply: apply, calleeAnalysis: context.calleeAnalysis)
+  if let result = value.at(path).visit(using: visitor, context) {
+    // The resulting effects are the argument effects to which `value` escapes to.
+    return result.ownership
+  } else {
+    // `value` has unknown escapes. So we have to take the global effects of the called function(s).
+    return visitor.calleeAnalysis.getSideEffects(of: apply).ownership
+  }
+}
+
+private struct SideEffectsVisitor : EscapeVisitorWithResult {
+  let apply: ApplySite
+  let calleeAnalysis: CalleeAnalysis
+  var result = SideEffects.GlobalEffects()
+
+  mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
+    let user = operand.instruction
+    if user is ReturnInst {
+      // Anything which is returned cannot escape to an instruction inside the function.
+      return .ignore
+    }
+    if user == apply {
+      if let argIdx = apply.argumentIndex(of: operand) {
+        let e = calleeAnalysis.getSideEffects(of: apply, forArgument: argIdx, path: path.projectionPath)
+        result.merge(with: e)
+      }
+    }
+    return .continueWalk
+  }
+}
+
+private extension Value {
+  /// Returns true if this address is passed as indirect out of `apply`.
+  func isIndirectResult(of apply: ApplySite) -> Bool {
+    guard let fullApply = apply as? FullApplySite else {
+      return false
+    }
+    if fullApply.numIndirectResultArguments == 0 {
+      return false
+    }
+
+    var walker = IsIndirectResultWalker(apply: fullApply)
+    return walker.walkDownUses(ofAddress: self, path: UnusedWalkingPath()) == .abortWalk
+  }
+}
+
+private struct IsIndirectResultWalker: AddressDefUseWalker {
+  let apply: FullApplySite
+
+  mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
+    if address.instruction == apply,
+       let argIdx = apply.argumentIndex(of: address),
+       argIdx < apply.numIndirectResultArguments {
+      return .abortWalk
+    }
+    return .continueWalk
+  }
 }
+

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -94,7 +94,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   var isValid: Bool {
     blockRange.isValid &&
     // Check if there are any inserted instructions before the begin instruction in its block.
-    !ReverseList(first: begin).dropFirst().contains { insertedInsts.contains($0) }
+    !ReverseInstructionList(first: begin).dropFirst().contains { insertedInsts.contains($0) }
   }
 
   /// Returns the end instructions.
@@ -115,7 +115,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   /// Returns the interior instructions.
   var interiors: LazySequence<FlattenSequence<
                    LazyMapSequence<Stack<BasicBlock>,
-                                   LazyFilterSequence<ReverseList<Instruction>>>>> {
+                                   LazyFilterSequence<ReverseInstructionList>>>> {
     blockRange.inserted.lazy.flatMap {
       var include = blockRange.contains($0)
       return $0.instructions.reversed().lazy.filter {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -75,8 +75,10 @@ private func registerSwiftPasses() {
   registerPass(deadEndBlockDumper, { deadEndBlockDumper.run($0) })
   registerPass(rangeDumper, { rangeDumper.run($0) })
   registerPass(runUnitTests, { runUnitTests.run($0) })
+  registerPass(testInstructionIteration, { testInstructionIteration.run($0) })
 }
 
 private func registerSwiftAnalyses() {
+  AliasAnalysis.register()
   CalleeAnalysis.register()
 }

SwiftCompilerSources/Sources/Optimizer/TestPasses/CMakeLists.txt

@@ -14,4 +14,5 @@ swift_compiler_sources(Optimizer
   SILPrinter.swift
   RangeDumper.swift
   RunUnitTests.swift
+  TestInstructionIteration.swift
 )

SwiftCompilerSources/Sources/Optimizer/TestPasses/TestInstructionIteration.swift

@@ -0,0 +1,77 @@
+//===--- TestInstructionIteration.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 SIL
+
+/// Tests instruction iteration while modifying the instruction list.
+///
+/// This pass iterates over the instruction list of the function's block and performs
+/// modifications of the instruction list - mostly deleting instructions.
+/// Modifications are triggered by `string_literal` instructions with known "commands".
+/// E.g. if a
+/// ```
+///   %1 = string_literal utf8 "delete_strings"
+/// ```
+/// is encountered during the iteration, it triggers the deletion of all `string_literal`
+/// instructions of the basic block (including the current one).
+let testInstructionIteration = FunctionPass(name: "test-instruction-iteration") {
+  (function: Function, context: PassContext) in
+
+  print("Test instruction iteration in \(function.name):")
+
+  let reverse = function.name.string.hasSuffix("backward")
+
+  for block in function.blocks {
+    print("\(block.name):")
+    let termLoc = block.terminator.location
+    if reverse {
+      for inst in block.instructions.reversed() {
+        handle(instruction: inst, context)
+      }
+    } else {
+      for inst in block.instructions {
+        handle(instruction: inst, context)
+      }
+    }
+    if block.instructions.isEmpty || !(block.instructions.reversed().first is TermInst) {
+      let builder = Builder(atEndOf: block, location: termLoc, context)
+      builder.createUnreachable()
+    }
+  }
+  print("End function \(function.name):")
+}
+
+private func handle(instruction: Instruction, _ context: PassContext) {
+  print(instruction)
+  if let sl = instruction as? StringLiteralInst {
+    switch sl.string {
+      case "delete_strings":
+        deleteAllInstructions(ofType: StringLiteralInst.self, in: instruction.block, context)
+      case "delete_ints":
+        deleteAllInstructions(ofType: IntegerLiteralInst.self, in: instruction.block, context)
+      case "delete_branches":
+        deleteAllInstructions(ofType: BranchInst.self, in: instruction.block, context)
+      case "split_block":
+        _ = context.splitBlock(at: instruction)
+      default:
+        break
+    }
+  }
+}
+
+private func deleteAllInstructions<InstType: Instruction>(ofType: InstType.Type, in block: BasicBlock, _ context: PassContext) {
+  for inst in block.instructions {
+    if inst is InstType {
+      context.erase(instruction: inst)
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -86,11 +86,6 @@ public enum ArgumentConvention {
   /// object.
   case indirectIn
 
-  /// This argument is passed indirectly, i.e. by directly passing the address
-  /// of an object in memory.  The callee must treat the object as read-only
-  /// The callee may assume that the address does not alias any valid object.
-  case indirectInConstant
-
   /// This argument is passed indirectly, i.e. by directly passing the address
   /// of an object in memory.  The callee may not modify and does not destroy
   /// the object.
@@ -130,7 +125,7 @@ public enum ArgumentConvention {
 
   public var isIndirect: Bool {
     switch self {
-    case .indirectIn, .indirectInConstant, .indirectInGuaranteed,
+    case .indirectIn, .indirectInGuaranteed,
          .indirectInout, .indirectInoutAliasable, .indirectOut:
       return true
     case .directOwned, .directUnowned, .directGuaranteed:
@@ -140,7 +135,7 @@ public enum ArgumentConvention {
 
   public var isIndirectIn: Bool {
     switch self {
-    case .indirectIn, .indirectInConstant, .indirectInGuaranteed:
+    case .indirectIn, .indirectInGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed,
          .indirectInout, .indirectInoutAliasable, .indirectOut:
@@ -152,7 +147,7 @@ public enum ArgumentConvention {
     switch self {
     case .indirectInGuaranteed, .directGuaranteed:
       return true
-    case .indirectIn, .indirectInConstant, .directOwned, .directUnowned,
+    case .indirectIn, .directOwned, .directUnowned,
          .indirectInout, .indirectInoutAliasable, .indirectOut:
       return false
     }
@@ -161,7 +156,6 @@ public enum ArgumentConvention {
   public var isExclusiveIndirect: Bool {
     switch self {
     case .indirectIn,
-         .indirectInConstant,
          .indirectOut,
          .indirectInGuaranteed,
          .indirectInout:
@@ -182,7 +176,6 @@ public enum ArgumentConvention {
       return true
 
     case .indirectIn,
-         .indirectInConstant,
          .indirectOut,
          .indirectInGuaranteed,
          .directUnowned,
@@ -205,7 +198,6 @@ extension BridgedArgumentConvention {
   var convention: ArgumentConvention {
     switch self {
       case ArgumentConvention_Indirect_In:             return .indirectIn
-      case ArgumentConvention_Indirect_In_Constant:    return .indirectInConstant
       case ArgumentConvention_Indirect_In_Guaranteed:  return .indirectInGuaranteed
       case ArgumentConvention_Indirect_Inout:          return .indirectInout
       case ArgumentConvention_Indirect_InoutAliasable: return .indirectInoutAliasable