Merge branch 'main' into smooth_operator

Author: angela-laar

CMakeLists.txt

@@ -192,8 +192,7 @@ set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
     option only affects the tools that run on the host (the compiler), and has
     no effect on the target libraries (the standard library and the runtime).")
 
-# NOTE: We do not currently support building the swift compiler modules with the Xcode generator.
-cmake_dependent_option(BOOTSTRAPPING_MODE [=[
+option(BOOTSTRAPPING_MODE [=[
 How to build the swift compiler modules. Possible values are
     OFF:           build without swift modules
     HOSTTOOLS:     build with a pre-installed toolchain
@@ -204,7 +203,7 @@ How to build the swift compiler modules. Possible values are
                    `SWIFT_NATIVE_SWIFT_TOOLS_PATH` (non-Darwin only)
     CROSSCOMPILE-WITH-HOSTLIBS:    build with a bootstrapping-with-hostlibs compiled
                                    compiler, provided in `SWIFT_NATIVE_SWIFT_TOOLS_PATH`
-]=]  OFF "NOT CMAKE_GENERATOR STREQUAL \"Xcode\"" OFF)
+]=] OFF)
 
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
@@ -530,7 +529,12 @@ include(CMakePushCheckState)
 
 # Print out path and version of any installed commands
 message(STATUS "CMake (${CMAKE_COMMAND}) Version: ${CMAKE_VERSION}")
-execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} --version
+if(XCODE)
+  set(version_flag -version)
+else()
+  set(version_flag --version)
+endif()
+execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} ${version_flag}
   OUTPUT_VARIABLE _CMAKE_MAKE_PROGRAM_VERSION
   OUTPUT_STRIP_TRAILING_WHITESPACE)
 message(STATUS "CMake Make Program (${CMAKE_MAKE_PROGRAM}) Version: ${_CMAKE_MAKE_PROGRAM_VERSION}")
@@ -1110,8 +1114,6 @@ if(SWIFT_INCLUDE_TOOLS)
   # SwiftCompilerSources must come before "tools".
   # It adds swift module names to the global property "swift_compiler_modules"
   # which is used in add_swift_host_tool for the lldb workaround.
-  #
-  # NOTE: We do not currently support SwiftCompilerSources with the Xcode generator.
   add_subdirectory(SwiftCompilerSources)
 
   # Always include this after including stdlib/!

SwiftCompilerSources/CMakeLists.txt

@@ -89,8 +89,7 @@ function(add_swift_compiler_modules_library name)
   set(sdk_option "")
 
   if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
-    set(deployment_version "10.15") # TODO: once #38675 lands, replace this with
-#   set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
+    set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
     set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
     if(${BOOTSTRAPPING_MODE} STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
       # Let the cross-compiled compile don't pick up the compiled stdlib by providing
@@ -120,7 +119,10 @@ function(add_swift_compiler_modules_library name)
     if (dependencies)
       foreach(dep_module ${dependencies})
         if (DEFINED "${dep_module}_dep_target")
-          list(APPEND deps "${${dep_module}_dep_target}")
+          # We have to add the module target for the ordering dependency
+          # and the output file for the file dependency (otherwise the dependent
+          # module wouldn't be rebuilt if the current module changes)
+          list(APPEND deps "${${dep_module}_dep_target}" "${build_dir}/${dep_module}.o")
         else()
           message(FATAL_ERROR "module dependency ${module} -> ${dep_module} not found. Make sure to add modules in dependency order")
         endif()
@@ -158,6 +160,15 @@ function(add_swift_compiler_modules_library name)
   add_dependencies(${name} ${all_module_targets})
   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
   set_property(GLOBAL APPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
+
+  # Xcode does not compile libraries that contain only object files.
+  # Therefore, it fails to create the static library. As a workaround,
+  # we add a dummy script phase to the target.
+  if (XCODE)
+    add_custom_command(TARGET ${name} POST_BUILD 
+      COMMAND ""
+      COMMENT "Dummy script phase to force building this target")
+  endif()
 endfunction()
 
 

SwiftCompilerSources/README.md

@@ -169,6 +169,6 @@ Some performance considerations:
 
 * Memory is managed on the C++ side. On the Swift side, SIL objects are treated as "immortal" objects, which avoids (most of) ARC overhead. ARC runtime functions are still being called, but no atomic reference counting operations are done. In future we could add a compiler feature to mark classes as immortal to avoid the runtime calls at all.
 
-* Minimizing memory allocations by using data structures which are malloc-free. For example `StackList` can be used in optimizations to implement work lists without any memory allocations. (Not yet done: `BasicBlockSet`, `BasicBlockData`)
+* Minimizing memory allocations by using data structures which are malloc-free, e.g. `Stack`
 
 * The Swift modules are compiled with `-cross-module-optimization`. This enables the compiler to optimize the Swift code across module boundaries.

SwiftCompilerSources/Sources/Optimizer/Analysis/CMakeLists.txt

@@ -8,4 +8,7 @@
 
 swift_compiler_sources(Optimizer
   AliasAnalysis.swift
-  CalleeAnalysis.swift)
+  CalleeAnalysis.swift
+  DeadEndBlocksAnalysis.swift
+  DominatorTree.swift
+  PostDominatorTree.swift)

SwiftCompilerSources/Sources/Optimizer/Analysis/CalleeAnalysis.swift

@@ -19,9 +19,14 @@ public struct CalleeAnalysis {
   public func getCallees(callee: Value) -> FunctionArray {
     return FunctionArray(bridged: CalleeAnalysis_getCallees(bridged, callee.bridged))
   }
+
+  public func getDestructors(destroyInst: Instruction) -> FunctionArray {
+    return FunctionArray(bridged:
+      CalleeAnalysis_getInstCallees(bridged, destroyInst.bridged))
+  }
 }
 
-public struct FunctionArray : RandomAccessCollection, CustomReflectable {
+public struct FunctionArray : RandomAccessCollection, FormattedLikeArray {
   fileprivate let bridged: BridgedCalleeList
 
   public var startIndex: Int { 0 }
@@ -32,9 +37,4 @@ public struct FunctionArray : RandomAccessCollection, CustomReflectable {
   }
 
   public var allCalleesKnown: Bool { bridged.incomplete == 0 }
-
-  public var customMirror: Mirror {
-    let c: [Mirror.Child] = map { (label: nil, value: $0.name) }
-    return Mirror(self, children: c)
-  }
 }

SwiftCompilerSources/Sources/Optimizer/Analysis/DeadEndBlocksAnalysis.swift

@@ -0,0 +1,22 @@
+//===--- DeadEndBlocksAnalysis.swift - the dead-end blocks analysis -------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 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
+import SIL
+
+public struct DeadEndBlocksAnalysis {
+  let bridged: BridgedDeadEndBlocksAnalysis
+
+  public func isDeadEnd(_ block: BasicBlock) -> Bool {
+    return DeadEndBlocksAnalysis_isDeadEnd(bridged, block.bridged) != 0
+  }
+}

SwiftCompilerSources/Sources/Optimizer/Analysis/DominatorTree.swift

@@ -0,0 +1,28 @@
+//===--- DominatorTree.swift - the dominator tree -------------------------===//
+//
+// 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
+import OptimizerBridging
+
+public struct DominatorTree {
+  let bridged: BridgedDomTree
+}
+
+extension BasicBlock {
+  func dominates(_ other: BasicBlock, _ domTree: DominatorTree) -> Bool {
+    DominatorTree_dominates(domTree.bridged, self.bridged, other.bridged) != 0
+  }
+  
+  func strictlyDominates(_ other: BasicBlock, _ domTree: DominatorTree) -> Bool {
+    dominates(other, domTree) && self != other
+  }
+}

SwiftCompilerSources/Sources/Optimizer/Analysis/PostDominatorTree.swift

@@ -0,0 +1,28 @@
+//===--- PostDominatorTree.swift - the post dominator tree ----------------===//
+//
+// 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
+import OptimizerBridging
+
+public struct PostDominatorTree {
+  let bridged: BridgedPostDomTree
+}
+
+extension BasicBlock {
+  func postDominates(_ other: BasicBlock, _ pdomTree: PostDominatorTree) -> Bool {
+    PostDominatorTree_postDominates(pdomTree.bridged, self.bridged, other.bridged) != 0
+  }
+  
+  func strictlyPostDominates(_ other: BasicBlock, _ pdomTree: PostDominatorTree) -> Bool {
+    postDominates(other, pdomTree) && self != other
+  }
+}

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -15,6 +15,7 @@ endif()
 add_swift_compiler_module(Optimizer DEPENDS ${dependencies})
 
 add_subdirectory(Analysis)
+add_subdirectory(DataStructures)
 add_subdirectory(InstructionPasses)
 add_subdirectory(PassManager)
 add_subdirectory(FunctionPasses)

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -0,0 +1,145 @@
+//===--- BasicBlockRange.swift - a range of basic blocks ------------------===//
+//
+// 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
+
+/// A range of basic blocks.
+///
+/// The `BasicBlockRange` defines a range from a dominating "begin" block to one or more "end" blocks.
+/// The range is "exclusive", which means that the "end" blocks are not part of the range.
+///
+/// The `BasicBlockRange` is in the same spirit as a linear range, but as the control flow is a graph
+/// and not a linear list, there can be "exit" blocks from within the range.
+///
+/// One or more "potential" end blocks can be inserted.
+/// Though, not all inserted blocks end up as "end" blocks.
+///
+/// There are several kind of blocks:
+/// * begin: it is a single block which dominates all blocks of the range
+/// * range: all blocks from which there is a path from the begin block to any of the end blocks
+/// * ends: all inserted blocks which are at the end of the range
+/// * exits: all successor blocks of range blocks which are not in the range themselves
+/// * interiors: all inserted blocks which are not end blocks.
+///
+/// In the following example, let's assume `B` is the begin block and `I1`, `I2` and `I3`
+/// were inserted as potential end blocks:
+///
+///     B
+///    / \
+///   I1 I2
+///      / \
+///     I3  X
+///
+/// Then `I1` and `I3` are "end" blocks. `I2` is an interior block and `X` is an exit block.
+/// The range consists of `B` and  `I2`. Note that the range does not include `I1` and `I3`
+/// because it's an _exclusive_ range.
+///
+/// This type should be a move-only type, but unfortunately we don't have move-only
+/// types yet. Therefore it's needed to call `deinitialize()` explicitly to
+/// destruct this data structure, e.g. in a `defer {}` block.
+struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
+
+  /// The dominating begin block.
+  let begin: BasicBlock
+
+  /// The exclusive range, i.e. not containing the end blocks.
+  private(set) var range: Stack<BasicBlock>
+  
+  /// All inserted blocks.
+  private(set) var inserted: Stack<BasicBlock>
+
+  private var insertedSet: BasicBlockSet
+  private var worklist: BasicBlockWorklist
+  
+  init(begin: BasicBlock, _ context: PassContext) {
+    self.begin = begin
+    self.range = Stack(context)
+    self.inserted = Stack(context)
+    self.insertedSet = BasicBlockSet(context)
+    self.worklist = BasicBlockWorklist(context)
+  }
+
+  /// Insert a potential end block.
+  mutating func insert(_ block: BasicBlock) {
+    if !insertedSet.contains(block) {
+      insertedSet.insert(block)
+      inserted.append(block)
+    }
+    if block != begin {
+      worklist.pushIfNotVisited(contentsOf: block.predecessors)
+
+      while let b = worklist.pop() {
+        range.append(b)
+        if b != begin {
+          worklist.pushIfNotVisited(contentsOf: b.predecessors)
+        }
+      }
+    }
+  }
+
+  /// Returns true if the exclusive range contains `block`.
+  func contains(_ block: BasicBlock) -> Bool { worklist.hasBeenPushed(block) }
+  
+  /// Returns true if the inclusive range contains `block`.
+  func inclusiveRangeContains (_ block: BasicBlock) -> Bool {
+    contains(block) || insertedSet.contains(block)
+  }
+
+  /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
+  var isValid: Bool {
+    let entry = begin.function.entryBlock
+    return begin == entry ||
+      // If any block in the range is not dominated by `begin`, the range propagates back to the entry block.
+      !inclusiveRangeContains(entry)
+  }
+
+  /// Returns the end blocks.
+  var ends: LazyFilterSequence<Stack<BasicBlock>> {
+    inserted.lazy.filter { !worklist.hasBeenPushed($0) }
+  }
+
+  /// Returns the exit blocks.
+  var exits: LazySequence<FlattenSequence<
+                    LazyMapSequence<Stack<BasicBlock>,
+                                    LazyFilterSequence<SuccessorArray>>>> {
+    range.lazy.flatMap {
+      $0.successors.lazy.filter {
+        !inclusiveRangeContains($0) || $0 == begin
+      }
+    }
+  }
+
+  /// Returns the interior blocks.
+  var interiors: LazyFilterSequence<Stack<BasicBlock>> {
+    inserted.lazy.filter { contains($0) && $0 != begin }
+  }
+  
+  var description: String {
+    """
+    begin:     \(begin.name)
+    range:     \(range)
+    ends:      \(ends)
+    exits:     \(exits)
+    interiors: \(interiors)
+    """
+  }
+
+  var customMirror: Mirror { Mirror(self, children: []) }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    worklist.deinitialize()
+    inserted.deinitialize()
+    insertedSet.deinitialize()
+    range.deinitialize()
+  }
+}