Merge remote-tracking branch 'origin/main' into felipe/fix_merge_opaque

The following tests required conflict resolutions, since upstream LLVM did a lot of
work to remove dbg.addr, and this work is not available to swift's main. At the
same time, swift's main changed these tests to enable opaque pointers.

```
both modified:   test/DebugInfo/async-let-await.swift
both modified:   test/DebugInfo/move_function_dbginfo.swift
both modified:   test/DebugInfo/move_function_dbginfo_async.swift
```

The conflicts are fairly easy to fix: we keep the "structure" of the CHECK
lines present in `next`, but replace all pointers with `ptr`.

Author: felipepiovezan

CMakeLists.txt

@@ -646,6 +646,11 @@ option(SWIFT_THREADING_PACKAGE
    Valid package names are 'pthreads', 'darwin', 'linux', 'win32', 'c11', 'none'
    or the empty string for the SDK default.")
 
+option(SWIFT_THREADING_HAS_DLSYM
+  "Enable the use of the dlsym() function.  This gets used to provide TSan
+   support on some platforms."
+  TRUE)
+
 option(SWIFT_ENABLE_MACCATALYST
   "Build the Standard Library and overlays with MacCatalyst support"
   FALSE)
@@ -1043,6 +1048,14 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "ANDROID")
   set(SWIFT_PRIMARY_VARIANT_SDK_default  "${SWIFT_HOST_VARIANT_SDK}")
   set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}")
 
+elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WASI")
+  set(SWIFT_HOST_VARIANT "wasi" CACHE STRING
+      "Deployment OS for Swift host tools (the compiler) [wasi]")
+
+  configure_sdk_unix("WASI" "wasm32")
+  set(SWIFT_PRIMARY_VARIANT_SDK_default  "${SWIFT_HOST_VARIANT_SDK}")
+  set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}")
+
 elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)")
 
   set(SWIFT_HOST_VARIANT "macosx" CACHE STRING

SwiftCompilerSources/Sources/Optimizer/DataStructures/Stack.swift

@@ -47,17 +47,17 @@ struct Stack<Element> : CollectionLikeSequence {
 
     mutating func next() -> Element? {
       let end = (slab.data == lastSlab.data ? endIndex : slabCapacity)
-      if index < end {
-        let elem = Stack.bind(slab)[index]
-        index += 1
-
-        if index >= end && slab.data != lastSlab.data {
-          slab = slab.getNext()
-          index = 0
-        }
-        return elem
+      
+      guard index < end else { return nil }
+    
+      let elem = Stack.bind(slab)[index]
+      index += 1
+      
+      if index >= end && slab.data != lastSlab.data {
+        slab = slab.getNext()
+        index = 0
       }
-      return nil
+      return elem
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -19,6 +19,7 @@ swift_compiler_sources(Optimizer
   SimplifyInitEnumDataAddr.swift
   SimplifyLoad.swift
   SimplifyPartialApply.swift
+  SimplifyRefCasts.swift
   SimplifyRetainReleaseValue.swift
   SimplifyStrongRetainRelease.swift
   SimplifyStructExtract.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyRefCasts.swift

@@ -0,0 +1,128 @@
+//===--- SimplifyRefCasts.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
+
+// Note: this simplifications are not SILCombineSimplifyable, because SILCombine has
+// its own simplifications for those cast instructions which are not ported to Swift, yet.
+
+extension CheckedCastBranchInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    // Has only an effect if the source is an (existential) reference.
+    simplifySourceOperandOfRefCast(context)
+  }
+}
+
+extension UncheckedRefCastInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    simplifySourceOperandOfRefCast(context)
+  }
+}
+
+private extension UnaryInstruction {
+
+  /// Look through `upcast` and `init_existential_ref` instructions and replace the
+  /// operand of this cast instruction with the original value.
+  /// For example:
+  /// ```
+  ///   %2 = upcast %1 : $Derived to $Base
+  ///   %3 = init_existential_ref %2 : $Base : $Base, $AnyObject
+  ///   checked_cast_br %3 : $AnyObject to Derived, bb1, bb2
+  /// ```
+  ///
+  /// This makes it more likely that the cast can be constant folded because the source
+  /// operand's type is more accurate. In the example above, the cast reduces to
+  /// ```
+  ///   checked_cast_br %1 : $Derived to Derived, bb1, bb2
+  /// ```
+  /// which can be trivially folded to always-succeeds.
+  ///
+  func simplifySourceOperandOfRefCast(_ context: SimplifyContext) {
+    while true {
+      switch operand.value {
+      case let ier as InitExistentialRefInst:
+        if !tryReplaceSource(withOperandOf: ier, context) {
+          return
+        }
+      case let uc as UpcastInst:
+        if !tryReplaceSource(withOperandOf: uc, context) {
+          return
+        }
+      default:
+        return
+      }
+    }
+
+  }
+
+  func tryReplaceSource(withOperandOf inst: SingleValueInstruction, _ context: SimplifyContext) -> Bool {
+    let singleUse = context.preserveDebugInfo ? inst.uses.singleUse : inst.uses.singleNonDebugUse
+    let canEraseInst = singleUse?.instruction == self
+    let replacement = inst.operands[0].value
+
+    if parentFunction.hasOwnership {
+      if !canEraseInst && replacement.ownership == .owned {
+        // We cannot add more uses to `replacement` without inserting a copy.
+        return false
+      }
+
+      operand.set(to: replacement, context)
+
+      if let ccb = self as? CheckedCastBranchInst {
+        // In OSSA, the source value is passed as block argument to the failure block.
+        // We have to re-create the skipped source instruction in the failure block.
+        insertCompensatingInstructions(for: inst, in: ccb.failureBlock, context)
+      }
+    } else {
+      operand.set(to: replacement, context)
+    }
+
+    if canEraseInst {
+      context.erase(instructionIncludingDebugUses: inst)
+    }
+    return true
+  }
+}
+
+/// Compensate a removed source value instruction in the failure block.
+/// For example:
+/// ```
+///   %inst = upcast %sourceValue : $Derived to $Base
+///   checked_cast_br %inst : $Base to Derived, success_block, failure_block
+///   ...
+/// failure_block(%oldArg : $Base):
+/// ```
+/// is converted to:
+/// ```
+///   checked_cast_br %sourceValue : $Derived to Derived, success_block, failure_block
+///   ...
+/// failure_block(%newArg : $Derived):
+///   %3 = upcast %newArg : $Derived to $Base
+/// ```
+private func insertCompensatingInstructions(for inst: Instruction, in failureBlock: BasicBlock, _ context: SimplifyContext) {
+  assert(failureBlock.arguments.count == 1)
+  let sourceValue = inst.operands[0].value
+  let newArg = failureBlock.addBlockArgument(type: sourceValue.type, ownership: sourceValue.ownership, context)
+  let builder = Builder(atBeginOf: failureBlock, context)
+  let newInst: SingleValueInstruction
+  switch inst {
+  case let ier as InitExistentialRefInst:
+    newInst = builder.createInitExistentialRef(instance: newArg, existentialType: ier.type, useConformancesOf: ier)
+  case let uc as UpcastInst:
+    newInst = builder.createUpcast(from: newArg, to: uc.type)
+  default:
+    fatalError("unhandled instruction")
+  }
+  let oldArg = failureBlock.arguments[0]
+  oldArg.uses.replaceAll(with: newInst, context)
+  failureBlock.eraseArgument(at: 0, context)
+}

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -524,10 +524,19 @@ private struct NoStores : ValueDefUseWalker, AddressDefUseWalker {
   var walkDownCache = WalkerCache<SmallProjectionPath>()
 
   mutating func leafUse(value: Operand, path: SmallProjectionPath) -> WalkResult {
-    if let ptai = value.instruction as? PointerToAddressInst {
+    switch value.instruction {
+    case let ptai as PointerToAddressInst:
       return walkDownUses(ofAddress: ptai, path: path)
+    case let bi as BuiltinInst:
+      switch bi.intrinsicID {
+      case .memcpy, .memmove:
+        return value.index != 0 ? .continueWalk : .abortWalk
+      default:
+        return .abortWalk
+      }
+    default:
+      return .abortWalk
     }
-    return .abortWalk
   }
 
   mutating func leafUse(address: Operand, path: SmallProjectionPath) -> WalkResult {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -262,4 +262,13 @@ public struct Builder {
     let store = bridged.createStore(source.bridged, destination.bridged, ownership.rawValue)
     return notifyNew(store.getAs(StoreInst.self))
   }
+
+  public func createInitExistentialRef(instance: Value,
+                                       existentialType: Type,
+                                       useConformancesOf: InitExistentialRefInst) -> InitExistentialRefInst {
+    let initExistential = bridged.createInitExistentialRef(instance.bridged,
+                                                           existentialType.bridged,
+                                                           useConformancesOf.bridged)
+    return notifyNew(initExistential.getAs(InitExistentialRefInst.self))
+  }
 }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -399,6 +399,10 @@ final public class BuiltinInst : SingleValueInstruction {
     return bridged.BuiltinInst_getID()
   }
 
+  public var intrinsicID: BridgedInstruction.IntrinsicID {
+    return bridged.BuiltinInst_getIntrinsicID()
+  }
+
   public var substitutionMap: SubstitutionMap {
     SubstitutionMap(bridged.BuiltinInst_getSubstitutionMap())
   }
@@ -1000,6 +1004,9 @@ final public class AwaitAsyncContinuationInst : TermInst, UnaryInstruction {
 }
 
 final public class CheckedCastBranchInst : TermInst, UnaryInstruction {
+  public var source: Value { operand.value }
+  public var successBlock: BasicBlock { bridged.CheckedCastBranch_getSuccessBlock().block }
+  public var failureBlock: BasicBlock { bridged.CheckedCastBranch_getFailureBlock().block }
 }
 
 final public class CheckedCastAddrBranchInst : TermInst, UnaryInstruction {

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -110,10 +110,10 @@ macro(configure_sdks_darwin)
   set(appletvos_arch "arm64")
   set(watchos_arch "armv7k" "arm64_32")
 
-  set(macosx_ver "10.9")
-  set(iphoneos_ver "8.0")
-  set(appletvos_ver "9.1")
-  set(watchos_ver "2.0")
+  set(macosx_ver "10.13")
+  set(iphoneos_ver "11.0")
+  set(appletvos_ver "11.0")
+  set(watchos_ver "4.0")
 
   set(macosx_vendor "apple")
   set(iphoneos_vendor "apple")

cmake/modules/AddSwift.cmake

@@ -259,6 +259,10 @@ function(_add_host_variant_c_compile_flags target)
       # (see revision d913eefcc93f8c80d6d1a6de4ea898a2838d8b6f)
       # This is required to build with VS2017 15.8+
       _ENABLE_EXTENDED_ALIGNED_STORAGE=1>)
+    if(SWIFT_HOST_VARIANT_ARCH MATCHES "ARM64|aarch64")
+      target_compile_options(${target} PRIVATE
+        $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:-D_STD_ATOMIC_USE_ARM64_LDAR_STLR=0>)
+    endif()
 
     # msvcprt's std::function requires RTTI, but we do not want RTTI data.
     # Emulate /GR-.

cmake/modules/AddSwiftUnittests.cmake

@@ -49,16 +49,24 @@ function(add_swift_unittest test_dirname)
   endif()
 
   # some headers switch their inline implementations based on
-  # SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY and
+  # SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY, SWIFT_STDLIB_HAS_DLSYM and
   # SWIFT_THREADING_PACKAGE definitions
   if(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
     target_compile_definitions("${test_dirname}" PRIVATE
       SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
   endif()
+  if(SWIFT_STDLIB_HAS_DLSYM)
+    target_compile_definitions("${test_dirname}" PRIVATE
+      "SWIFT_STDLIB_HAS_DLSYM=1")
+  else()
+    target_compile_definitions("${test_dirname}" PRIVATE
+      "SWIFT_STDLIB_HAS_DLSYM=0")
+  endif()
 
   string(TOUPPER "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_THREADING_PACKAGE}" _threading_package)
   target_compile_definitions("${test_dirname}" PRIVATE
-    "SWIFT_THREADING_${_threading_package}")
+    "SWIFT_THREADING_${_threading_package}"
+    "SWIFT_THREADING_STATIC")
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     if(SWIFT_USE_LINKER)

docs/HowToGuides/GettingStarted.md

@@ -157,6 +157,7 @@ toolchain as a one-off, there are a couple of differences:
 ### Linux
 
 1. The latest Linux dependencies are listed in the respective Dockerfiles:
+   * [Ubuntu 18.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/18.04/Dockerfile)
    * [Ubuntu 20.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/20.04/Dockerfile)
    * [Ubuntu 22.04](https://github.com/apple/swift-docker/blob/main/swift-ci/master/ubuntu/22.04/Dockerfile)
    * [CentOS 7](https://github.com/apple/swift-docker/blob/main/swift-ci/master/centos/7/Dockerfile)

docs/Lexicon.md

@@ -188,6 +188,12 @@ guarantee this. This was
 "Do not merge". Placed in PR titles where discussion or analysis is still
 ongoing.
 
+## DSO
+
+Dynamic shared object, a shared library file (.so/.dylib/.dll, the extension of
+which depends on the platform) to be used by multiple applications while they
+are executing.
+
 ## dup
 
 From "duplicate". As a noun, refers to another filed issue that describes
@@ -250,6 +256,18 @@ A representation of all generic parameters and their requirements. Like
 types, generic signatures can be [canonicalized](#canonical-type) to be
 compared directly.
 
+## GOT
+
+[Global offset table](https://en.wikipedia.org/wiki/Global_Offset_Table),
+a section in an executable or a shared library, which enables code to run
+independently of the memory address where it is loaded at runtime. Entries
+in GOT directly point to absolute addresses of symbols. The format of GOT
+is platform-dependent. Loaders update GOT relocations either on
+startup or on symbol access.
+
+Additionally, IRGen makes heavy usage of "GOT" as in "GOT-equivalent variable"
+to describe the way it forms references to global objects that may or may not be external references. 
+
 ## iff
 
 ["if and only if"](https://en.wikipedia.org/wiki/If_and_only_if). This term comes from mathematics.
@@ -457,6 +475,12 @@ only to accelerate the process of reading C/C++/Objective-C headers, such as
 the bridging headers read in by the `-import-objc-header` command-line
 flag to swiftc.
 
+## PLT
+
+Procedure linkage table, which is used to call external functions that don't
+have their addresses known at link time. These addresses are then resolved
+by a loader at run time.
+
 ## PR
 
 1. "Problem Report": An issue reported in [LLVM's bug tracker](https://llvm.org/bugs/).

include/swift/ABI/GenericContext.h

@@ -183,10 +183,11 @@ class TargetGenericRequirementDescriptor {
     return offsetof(typename std::remove_reference<decltype(*this)>::type, Param);
   }
 
-  /// Retrieve the right-hand type for a SameType or BaseClass requirement.
+  /// Retrieve the right-hand type for a SameType, BaseClass or SameShape requirement.
   llvm::StringRef getMangledTypeName() const {
     assert(getKind() == GenericRequirementKind::SameType ||
-           getKind() == GenericRequirementKind::BaseClass);
+           getKind() == GenericRequirementKind::BaseClass ||
+           getKind() == GenericRequirementKind::SameShape);
     return swift::Demangle::makeSymbolicMangledNameStringRef(Type.get());
   }