Merge branch 'main' into wip-generic-reqs-from-actor-da-for-accessor

Author: ktoso

SwiftCompilerSources/CMakeLists.txt

@@ -59,7 +59,33 @@ function(swift_compiler_sources module)
   set(target_name "SwiftModule${module}")
   set_property(TARGET "SwiftModule${module}" APPEND PROPERTY SOURCES ${sources})
 endfunction()
- 
+
+# Allow the override of the flags used to define the SDK used to compile the
+# Swift compiler sources from the CMake configuration (command line or cache
+# files). This allows supporting complicated sysroots and some cross-compilation
+# scenarios.
+set(SWIFT_COMPILER_SOURCES_SDK_FLAGS_default)
+if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
+  set(sdk_path "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
+  list(APPEND SWIFT_COMPILER_SOURCES_SDK_FLAGS_default "-sdk" "${sdk_path}")
+  if(NOT EXISTS "${sdk_path}/usr/include/c++")
+    # Darwin SDKs in Xcode 12 or older do not include libc++, which prevents clang from finding libc++ when invoked
+    # from ClangImporter. This results in build errors. To workaround this, let's explicitly pass the path to libc++
+    # to clang.
+    message(WARNING "Building with an outdated Darwin SDK: libc++ missing from the ${SWIFT_HOST_VARIANT_SDK} SDK. Will use libc++ from the toolchain.")
+    get_filename_component(absolute_libcxx_path "${CMAKE_C_COMPILER}/../../include/c++/v1" REALPATH)
+    if (EXISTS "${absolute_libcxx_path}")
+      list(APPEND SWIFT_COMPILER_SOURCES_SDK_FLAGS_default "-Xcc" "-isystem" "-Xcc" "${absolute_libcxx_path}")
+    else()
+      message(ERROR "libc++ not found in the toolchain.")
+    endif()
+  endif()
+elseif(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE")
+  list(APPEND SWIFT_COMPILER_SOURCES_SDK_FLAGS_default "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
+endif()
+set(SWIFT_COMPILER_SOURCES_SDK_FLAGS ${SWIFT_COMPILER_SOURCES_SDK_FLAGS_default}
+  CACHE STRING "Swift flags used to compiler the Swift compiler sources")
+
 # Add a library target for the swift compiler modules.
 #
 # Adds targets to compile all swift compiler modules and a target for the
@@ -75,6 +101,7 @@ function(add_swift_compiler_modules_library name)
   set(swift_compile_options
       "-Xfrontend" "-validate-tbd-against-ir=none"
       "-Xfrontend" "-enable-experimental-cxx-interop"
+      "-Xfrontend" "-disable-target-os-checking"
       "-Xcc" "-std=c++17"
       "-Xcc" "-DCOMPILED_WITH_SWIFT"
       "-Xcc" "-UIBOutlet" "-Xcc" "-UIBAction" "-Xcc" "-UIBInspectable")
@@ -102,35 +129,22 @@ function(add_swift_compiler_modules_library name)
 
   get_bootstrapping_path(build_dir ${CMAKE_CURRENT_BINARY_DIR} "${ALS_BOOTSTRAPPING}")
 
-  set(sdk_option "")
+  set(sdk_option ${SWIFT_COMPILER_SOURCES_SDK_FLAGS})
 
   if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
     set(deployment_version "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
-    set(sdk_path "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
-    set(sdk_option "-sdk" "${sdk_path}")
     if(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE-WITH-HOSTLIBS")
       # Let the cross-compiled compile don't pick up the compiled stdlib by providing
       # an (almost) empty resource dir.
       # The compiler will instead pick up the stdlib from the SDK.
       get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
-      set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../bootstrapping0/lib/swift")
-    endif()
-    if(NOT EXISTS "${sdk_path}/usr/include/c++")
-      # Darwin SDKs in Xcode 12 or older do not include libc++, which prevents clang from finding libc++ when invoked
-      # from ClangImporter. This results in build errors. To workaround this, let's explicitly pass the path to libc++
-      # to clang.
-      message(WARNING "Building with an outdated Darwin SDK: libc++ missing from the ${SWIFT_HOST_VARIANT_SDK} SDK. Will use libc++ from the toolchain.")
-      get_filename_component(absolute_libcxx_path "${CMAKE_C_COMPILER}/../../include/c++/v1" REALPATH)
-      if (EXISTS "${absolute_libcxx_path}")
-        set(sdk_option ${sdk_option} "-Xcc" "-isystem" "-Xcc" "${absolute_libcxx_path}")
-      else()
-        message(ERROR "libc++ not found in the toolchain.")
-      endif()
+      list(APPEND sdk_option "-resource-dir" "${swift_exec_bin_dir}/../bootstrapping0/lib/swift")
     endif()
   elseif(BOOTSTRAPPING_MODE STREQUAL "CROSSCOMPILE")
-    set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
     get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
-    set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../lib/swift")
+    # NOTE: prepending allows SWIFT_COMPILER_SOURCES_SDK_FLAGS to override the
+    # resource directory if needed.
+    list(PREPEND sdk_option "-resource-dir" "${swift_exec_bin_dir}/../lib/swift")
   endif()
   get_versioned_target_triple(target ${SWIFT_HOST_VARIANT_SDK}
       ${SWIFT_HOST_VARIANT_ARCH} "${deployment_version}")
@@ -139,7 +153,7 @@ function(add_swift_compiler_modules_library name)
   # under `include/swift`. These are either located next to the compiler (in case of open source toolchains) or
   # in the SDK (in case a Swift compiler from Xcode)
   get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
-  set(sdk_option ${sdk_option} "-I" "${swift_exec_bin_dir}/../lib" "-I" "${sdk_path}/usr/lib")
+  list(APPEND sdk_option "-I" "${swift_exec_bin_dir}/../lib" "-I" "${sdk_path}/usr/lib")
 
   set(all_obj_files)
   set(all_module_targets)
@@ -262,6 +276,15 @@ else()
   add_library(importedHeaderDependencies "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp")
   target_include_directories(importedHeaderDependencies PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../include/swift")
 
+  # When building unified, we need to make sure all the Clang headers are
+  # generated before we try to use them.
+  # When building Swift against an already compiled LLVM/Clang, like
+  # build-script does, this target does not exist, but the headers
+  # are already completely generated at that point.
+  if(TARGET clang-tablegen-targets)
+    add_dependencies(importedHeaderDependencies clang-tablegen-targets)
+  endif()
+
   if(BOOTSTRAPPING_MODE MATCHES "HOSTTOOLS|CROSSCOMPILE")
 
     if (NOT SWIFT_EXEC_FOR_SWIFT_MODULES)

SwiftCompilerSources/Sources/Basic/CMakeLists.txt

@@ -9,4 +9,5 @@
 add_swift_compiler_module(Basic
   SOURCES
     SourceLoc.swift
+    StringParser.swift
     Utils.swift)

SwiftCompilerSources/Sources/Basic/StringParser.swift

@@ -0,0 +1,75 @@
+//===--- StringParser.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
+//
+//===----------------------------------------------------------------------===//
+
+/// A simple utility to parse a string.
+public struct StringParser {
+  private var s: Substring
+  private let originalLength: Int
+  
+  private mutating func consumeWhitespace() {
+    s = s.drop { $0.isWhitespace }
+  }
+
+  public init(_ string: String) {
+    s = Substring(string)
+    originalLength = string.count
+  }
+  
+  public mutating func isEmpty() -> Bool {
+    consumeWhitespace()
+    return s.isEmpty
+  }
+
+  public mutating func consume(_ str: String) -> Bool {
+    consumeWhitespace()
+    if !s.starts(with: str) { return false }
+    s = s.dropFirst(str.count)
+    return true
+  }
+
+  public mutating func consumeInt(withWhiteSpace: Bool = true) -> Int? {
+    if withWhiteSpace {
+      consumeWhitespace()
+    }
+    var intStr = ""
+    s = s.drop {
+      if $0.isNumber {
+        intStr.append($0)
+        return true
+      }
+      return false
+    }
+    return Int(intStr)
+  }
+  
+  public mutating func consumeIdentifier() -> String? {
+    consumeWhitespace()
+    var name = ""
+    s = s.drop {
+      if $0.isLetter {
+        name.append($0)
+        return true
+      }
+      return false
+    }
+    return name.isEmpty ? nil : name
+  }
+  
+  public func throwError(_ message: StaticString) throws -> Never {
+    throw ParsingError(message: message, position: originalLength - s.count)
+  }
+}
+
+public struct ParsingError : Error {
+  public let message: StaticString
+  public let position: Int
+}

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -12,8 +12,6 @@ swift_compiler_sources(Optimizer
   EscapeUtils.swift
   OptUtils.swift
   ForwardingUtils.swift
-  WalkUtils.swift
-  AccessUtils.swift
   SSAUpdater.swift
   StaticInitCloner.swift
   Test.swift

SwiftCompilerSources/Sources/Optimizer/Utilities/Devirtualization.swift

@@ -36,7 +36,7 @@ private func devirtualize(destroy: some DevirtualizableDestroy, _ context: some
   precondition(type.isNominal, "non-copyable non-nominal types not supported, yet")
 
   let result: Bool
-  if type.nominal.hasValueDeinit && !destroy.hasDropDeinit {
+  if type.nominal.hasValueDeinit && !destroy.shouldDropDeinit {
     guard let deinitFunc = context.lookupDeinit(ofNominal: type.nominal) else {
       return false
     }
@@ -58,6 +58,7 @@ private func devirtualize(destroy: some DevirtualizableDestroy, _ context: some
 
 // Used to dispatch devirtualization tasks to `destroy_value` and `destroy_addr`.
 private protocol DevirtualizableDestroy : UnaryInstruction {
+  var shouldDropDeinit: Bool { get }
   func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext)
   func devirtualizeStructFields(_ context: some MutatingContext) -> Bool
   func devirtualizeEnumPayload(enumCase: EnumCase, in block: BasicBlock, _ context: some MutatingContext) -> Bool
@@ -67,8 +68,6 @@ private protocol DevirtualizableDestroy : UnaryInstruction {
 private extension DevirtualizableDestroy {
   var type: Type { operand.value.type }
 
-  var hasDropDeinit: Bool { operand.value.lookThoughOwnershipInstructions is DropDeinitInst }
-
   func devirtualizeEnumPayloads(_ context: some MutatingContext) -> Bool {
     guard let cases = type.getEnumCases(in: parentFunction) else {
       return false
@@ -99,6 +98,8 @@ private extension DevirtualizableDestroy {
 }
 
 extension DestroyValueInst : DevirtualizableDestroy {
+  fileprivate var shouldDropDeinit: Bool { operand.value.lookThoughOwnershipInstructions is DropDeinitInst }
+
   fileprivate func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext) {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: type)
@@ -162,6 +163,11 @@ extension DestroyValueInst : DevirtualizableDestroy {
 }
 
 extension DestroyAddrInst : DevirtualizableDestroy {
+  fileprivate var shouldDropDeinit: Bool {
+    // The deinit is always called by a destroy_addr. There must not be a `drop_deinit` as operand.
+    false
+  }
+
   fileprivate func createDeinitCall(to deinitializer: Function, _ context: some MutatingContext) {
     let builder = Builder(before: self, context)
     let subs = context.getContextSubstitutionMap(for: destroyedAddress.type)

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -322,22 +322,6 @@ extension LoadInst {
   }
 }
 
-extension SmallProjectionPath {
-  /// Returns true if the path only contains projections which can be materialized as
-  /// SIL struct or tuple projection instructions - for values or addresses.
-  var isMaterializable: Bool {
-    let (kind, _, subPath) = pop()
-    switch kind {
-    case .root:
-      return true
-    case .structField, .tupleField:
-      return subPath.isMaterializable
-    default:
-      return false
-    }
-  }
-}
-
 extension FunctionPassContext {
   /// Returns true if any blocks were removed.
   func removeDeadBlocks(in function: Function) -> Bool {

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -22,10 +22,12 @@ add_swift_compiler_module(SIL
     Location.swift
     Operand.swift
     Registration.swift
-    SmallProjectionPath.swift
+    SILStage.swift
     SubstitutionMap.swift
     Type.swift
-    Utils.swift
     Value.swift
     VTable.swift
     WitnessTable.swift)
+
+add_subdirectory(Utilities)
+

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -203,13 +203,19 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     case none
     case noAllocations
     case noLocks
+    case noRuntime
+    case noExistentials
+    case noObjCRuntime
   }
 
   public var performanceConstraints: PerformanceConstraints {
     switch bridged.getPerformanceConstraints() {
       case .None: return .none
       case .NoAllocation: return .noAllocations
       case .NoLocks: return .noLocks
+      case .NoRuntime: return .noRuntime
+      case .NoExistentials: return .noExistentials
+      case .NoObjCBridging: return .noObjCRuntime
       default: fatalError("unknown performance constraint")
     }
   }
@@ -368,6 +374,24 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
       { (f: BridgedFunction, observeRetains: Bool) -> BridgedMemoryBehavior in
         let e = f.function.getSideEffects()
         return e.getMemBehavior(observeRetains: observeRetains)
+      },
+      // argumentMayRead  (used by the MemoryLifetimeVerifier)
+      { (f: BridgedFunction, bridgedArgOp: BridgedOperand, bridgedAddr: BridgedValue) -> Bool in
+        let argOp = Operand(bridged: bridgedArgOp)
+        let addr = bridgedAddr.value
+        let applySite = argOp.instruction as! FullApplySite
+        let addrPath = addr.accessPath
+        let argIdx = argOp.index - ApplyOperands.firstArgumentIndex
+        let calleeArgIdx = applySite.calleeArgIndex(callerArgIndex: argIdx)
+        let convention = applySite.getArgumentConvention(calleeArgIndex: calleeArgIdx)
+        assert(convention.isIndirectIn || convention.isInout)
+        let argPath = argOp.value.accessPath
+        assert(!argPath.isDistinct(from: addrPath))
+        let path = argPath.getProjection(to: addrPath) ?? SmallProjectionPath()
+        let effects = f.function.getSideEffects(forArgument: argOp.value.at(path),
+                                                atIndex: calleeArgIdx,
+                                                withConvention: convention)
+        return effects.memory.read
       }
     )
   }

SwiftCompilerSources/Sources/SIL/SILStage.swift

@@ -0,0 +1,40 @@
+//===--- SILStage.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
+//
+//===----------------------------------------------------------------------===//
+
+public enum SILStage: Int {
+  /// "Raw" SIL, emitted by SILGen, but not yet run through guaranteed
+  /// optimization and diagnostic passes.
+  ///
+  /// Raw SIL does not have fully-constructed SSA and may contain undiagnosed
+  /// dataflow errors.
+  case raw
+
+  /// Canonical SIL, which has been run through at least the guaranteed
+  /// optimization and diagnostic passes.
+  ///
+  /// Canonical SIL has stricter invariants than raw SIL. It must not contain
+  /// dataflow errors, and some instructions must be canonicalized to simpler
+  /// forms.
+  case canonical
+
+  /// Lowered SIL, which has been prepared for IRGen and will no longer
+  /// be passed to canonical SIL transform passes.
+  ///
+  /// In lowered SIL, the SILType of all SILValues is its SIL storage
+  /// type. Explicit storage is required for all address-only and resilient
+  /// types.
+  ///
+  /// Generating the initial Raw SIL is typically referred to as lowering (from
+  /// the AST). To disambiguate, refer to the process of generating the lowered
+  /// stage of SIL as "address lowering".
+  case lowered
+}