Merge rebranch into main to support stable/20230725 llvm-project branch

CMakeLists.txt

@@ -353,6 +353,12 @@ How swift-C++ bridging code is compiled:
     DEFAULT:      based on the build configuration
 ]=] DEFAULT)
 
+option(SWIFT_USE_SYMLINKS "Use symlinks instead of copying binaries" ${CMAKE_HOST_UNIX})
+set(SWIFT_COPY_OR_SYMLINK "copy")
+if(SWIFT_USE_SYMLINKS)
+  set(SWIFT_COPY_OR_SYMLINK "create_symlink")
+endif()
+
 # The following only works with the Ninja generator in CMake >= 3.0.
 set(SWIFT_PARALLEL_LINK_JOBS "" CACHE STRING
   "Define the maximum number of linker jobs for swift.")
@@ -1333,6 +1339,15 @@ endif()
 add_subdirectory(include)
 
 if(SWIFT_INCLUDE_TOOLS)
+
+  # TODO Remove this once release/5.9 is done and we can finish migrating Swift
+  #      off of `llvm::None`/`llvm::Optional`, and `llvm::makeArrayRef`.
+  # This is to silence the avalanche of deprecation warnings from LLVM headers
+  # until we can actually do something about them. This is nasty, but it's
+  # better than losing context due to the sheer number in-actionable deprecation
+  # warnings or the massive number of merge-conflicts we would get otherwise.
+  add_definitions(-DSWIFT_TARGET)
+
   # Include 'swift-syntax'.
   # This is a function because we want to set some 'CMAKE_*' variables temporarily.'
   # TODO: Replace this with 'block()' after CMake 3.25

cmake/modules/Libdispatch.cmake

@@ -8,15 +8,14 @@ if(NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     set(SWIFT_LIBDISPATCH_CXX_COMPILER ${CMAKE_CXX_COMPILER})
   elseif(CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME)
     if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
-      if(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR AND
-        TARGET clang)
+      if(DEFINED SWIFT_CLANG_LOCATION)
+        set(SWIFT_LIBDISPATCH_C_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(SWIFT_LIBDISPATCH_CXX_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+      elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR AND TARGET clang)
         set(SWIFT_LIBDISPATCH_C_COMPILER
           $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
         set(SWIFT_LIBDISPATCH_CXX_COMPILER
           $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-      elseif(DEFINED SWIFT_CLANG_LOCATION)
-        set(SWIFT_LIBDISPATCH_C_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-        set(SWIFT_LIBDISPATCH_CXX_COMPILER ${SWIFT_CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
       else()
         set(SWIFT_LIBDISPATCH_C_COMPILER clang-cl${CMAKE_EXECUTABLE_SUFFIX})
         set(SWIFT_LIBDISPATCH_CXX_COMPILER clang-cl${CMAKE_EXECUTABLE_SUFFIX})

cmake/modules/SwiftComponents.cmake

@@ -203,6 +203,9 @@ function(swift_install_symlink_component component)
   # otherwise.
   install(DIRECTORY DESTINATION "${ARG_DESTINATION}" COMPONENT ${component})
   install(SCRIPT ${INSTALL_SYMLINK}
-          CODE "install_symlink(${ARG_LINK_NAME} ${ARG_TARGET} ${ARG_DESTINATION})"
+          CODE "install_symlink(${ARG_LINK_NAME}
+                                ${ARG_TARGET}
+                                ${ARG_DESTINATION}
+                                ${SWIFT_COPY_OR_SYMLINK})"
           COMPONENT ${component})
 endfunction()

include/swift/ABI/ObjectFile.h

@@ -7,8 +7,9 @@
 #ifndef SWIFT_ABI_OBJECTFILE_H
 #define SWIFT_ABI_OBJECTFILE_H
 
-#include "llvm/Support/ErrorHandling.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace swift {
 

include/swift/AST/ASTContext.h

@@ -506,9 +506,9 @@ class ASTContext final {
     return StringRef(Result.data(), Result.size());
   }
 
-  template<typename T, typename Vector, typename Set>
+  template<typename T, typename Vector, typename Set, unsigned N>
   MutableArrayRef<T>
-  AllocateCopy(llvm::SetVector<T, Vector, Set> setVector,
+  AllocateCopy(llvm::SetVector<T, Vector, Set, N> setVector,
                AllocationArena arena = AllocationArena::Permanent) const {
     return MutableArrayRef<T>(AllocateCopy<T>(setVector.begin(),
                                               setVector.end(),

include/swift/AST/ASTWalker.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/PointerUnion.h"
 #include <utility>
 

include/swift/AST/Decl.h

@@ -5016,7 +5016,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// \c None if it hasn't yet been computed.
   llvm::Optional<bool> getCachedHasSelfOrAssociatedTypeRequirements() {
     if (Bits.ProtocolDecl.HasSelfOrAssociatedTypeRequirementsValid)
-      return Bits.ProtocolDecl.HasSelfOrAssociatedTypeRequirements;
+      return static_cast<bool>(Bits.ProtocolDecl.HasSelfOrAssociatedTypeRequirements);
 
     return llvm::None;
   }

include/swift/AST/FileUnit.h

@@ -122,7 +122,7 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
   /// collecting the identifiers in \p spiGroups.
   virtual void lookupImportedSPIGroups(
                             const ModuleDecl *importedModule,
-                            SmallSetVector<Identifier, 4> &spiGroups) const {};
+                            llvm::SmallSetVector<Identifier, 4> &spiGroups) const {};
 
   /// Checks whether this file imports \c module as \c @_weakLinked.
   virtual bool importsModuleAsWeakLinked(const ModuleDecl *module) const {

include/swift/AST/IRGenOptions.h

@@ -502,6 +502,15 @@ class IRGenOptions {
   /// The calling convention used to perform non-swift calls.
   llvm::CallingConv::ID PlatformCCallingConvention;
 
+  /// Use CAS based object format as the output.
+  bool UseCASBackend;
+
+  /// The output mode for the CAS Backend.
+  llvm::CASBackendMode CASObjMode;
+
+  /// Emit a .casid file next to the object file if CAS Backend is used.
+  bool EmitCASIDFile;
+
   IRGenOptions()
       : DWARFVersion(2),
         OutputKind(IRGenOutputKind::LLVMAssemblyAfterOptimization),
@@ -513,9 +522,9 @@ class IRGenOptions {
         DebugInfoFormat(IRGenDebugInfoFormat::None),
         DisableClangModuleSkeletonCUs(false), UseJIT(false),
         DisableLLVMOptzns(false), DisableSwiftSpecificLLVMOptzns(false),
-        Playground(false),
-        EmitStackPromotionChecks(false), UseSingleModuleLLVMEmission(false),
-        FunctionSections(false), PrintInlineTree(false), AlwaysCompile(false),
+        Playground(false), EmitStackPromotionChecks(false),
+        UseSingleModuleLLVMEmission(false), FunctionSections(false),
+        PrintInlineTree(false), AlwaysCompile(false),
         EmbedMode(IRGenEmbedMode::None), LLVMLTOKind(IRGenLLVMLTOKind::None),
         SwiftAsyncFramePointer(SwiftAsyncFramePointerKind::Auto),
         HasValueNamesSetting(false), ValueNames(false),
@@ -538,13 +547,12 @@ class IRGenOptions {
         WitnessMethodElimination(false), ConditionalRuntimeRecords(false),
         InternalizeAtLink(false), InternalizeSymbols(false),
         EmitGenericRODatas(false), NoPreallocatedInstantiationCaches(false),
-        DisableReadonlyStaticObjects(false),
-        CollocatedMetadataFunctions(false),
-        ColocateTypeDescriptors(true),
-        UseRelativeProtocolWitnessTables(false), CmdArgs(),
-        SanitizeCoverage(llvm::SanitizerCoverageOptions()),
+        DisableReadonlyStaticObjects(false), CollocatedMetadataFunctions(false),
+        ColocateTypeDescriptors(true), UseRelativeProtocolWitnessTables(false),
+        CmdArgs(), SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All),
-        PlatformCCallingConvention(llvm::CallingConv::C) {
+        PlatformCCallingConvention(llvm::CallingConv::C), UseCASBackend(false),
+        CASObjMode(llvm::CASBackendMode::Native) {
 #ifndef NDEBUG
     DisableRoundTripDebugTypes = false;
 #else

include/swift/AST/Import.h

@@ -776,15 +776,15 @@ struct DenseMapInfo<swift::AttributedImport<ModuleInfo>> {
                             SourceLocDMI::getEmptyKey(),
                             ImportOptionsDMI::getEmptyKey(),
                             StringRefDMI::getEmptyKey(),
-                            {}, {}, None,
+                            {}, {}, llvm::None,
                             swift::AccessLevel::Public, {});
   }
   static inline AttributedImport getTombstoneKey() {
     return AttributedImport(ModuleInfoDMI::getTombstoneKey(),
                             SourceLocDMI::getEmptyKey(),
                             ImportOptionsDMI::getTombstoneKey(),
                             StringRefDMI::getTombstoneKey(),
-                            {}, {}, None,
+                            {}, {}, llvm::None,
                             swift::AccessLevel::Public, {});
   }
   static inline unsigned getHashValue(const AttributedImport &import) {

include/swift/AST/Module.h

@@ -33,6 +33,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/ErrorHandling.h"

include/swift/AST/ModuleLoader.h

@@ -24,6 +24,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Located.h"
 #include "swift/Basic/SourceLoc.h"
+#include "clang/Basic/FileManager.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSet.h"

include/swift/AST/ResilienceExpansion.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_RESILIENCE_EXPANSION_H
 
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace swift {
 

include/swift/AST/SearchPathOptions.h

@@ -19,6 +19,8 @@
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/None.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/VirtualFileSystem.h"
 

include/swift/Basic/BlotMapVector.h

@@ -16,6 +16,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Range.h"
+#include "llvm/ADT/Optional.h"
 #include <vector>
 
 namespace swift {

include/swift/Basic/Cache.h

@@ -15,8 +15,9 @@
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace swift {
 namespace sys {

include/swift/Basic/ClusteredBitVector.h

@@ -216,7 +216,7 @@ class ClusteredBitVector {
 
   /// Count the number of set bits in this vector.
   size_t count() const {
-    return Bits ? Bits.value().countPopulation() : 0;
+    return Bits ? Bits.value().popcount() : 0;
   }
 
   /// Determine if there are any bits set in this vector.

include/swift/Basic/EncodedSequence.h

@@ -25,7 +25,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/PrefixMap.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/Host.h"
+#include "llvm/TargetParser/Host.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <climits>
 

include/swift/Basic/Fingerprint.h

@@ -18,6 +18,7 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <string>
 

include/swift/Basic/FixedBitSet.h

@@ -218,9 +218,8 @@ class FixedBitSet {
 
     ValueType operator*() const {
       assert(remainingChunk && "dereferencing a completed iterator");
-      return ValueType(chunkIndex * chunkSize
-                         + llvm::findFirstSet(remainingChunk,
-                                              llvm::ZB_Undefined));
+      return ValueType(chunkIndex * chunkSize +
+                       llvm::countr_zero(remainingChunk));
     }
 
     bool operator==(const iterator &other) const {

include/swift/Basic/ImmutablePointerSet.h

@@ -48,10 +48,11 @@
 #ifndef SWIFT_BASIC_IMMUTABLEPOINTERSET_H
 #define SWIFT_BASIC_IMMUTABLEPOINTERSET_H
 
-#include "swift/Basic/STLExtras.h"
 #include "swift/Basic/NullablePtr.h"
-#include "llvm/Support/Allocator.h"
+#include "swift/Basic/STLExtras.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/Allocator.h"
 #include <algorithm>
 #include <type_traits>
 

include/swift/Basic/LLVM.h

@@ -53,7 +53,6 @@ namespace llvm {
   template <typename T, unsigned N> class SmallVector;
 #endif
   template <unsigned N> class SmallString;
-  template <typename T, unsigned N> class SmallSetVector;
 #if SWIFT_LLVM_ODR_SAFE
   template<typename T> class ArrayRef;
   template<typename T> class MutableArrayRef;
@@ -93,7 +92,6 @@ namespace swift {
   using llvm::SmallBitVector;
   using llvm::SmallPtrSet;
   using llvm::SmallPtrSetImpl;
-  using llvm::SmallSetVector;
   using llvm::SmallString;
 #if SWIFT_LLVM_ODR_SAFE
   using llvm::SmallVector;

include/swift/Basic/LLVMExtras.h

@@ -0,0 +1,36 @@
+//===--- LLVMExtras.h -----------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides additional functionality on top of LLVM types
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_LLVMEXTRAS_H
+#define SWIFT_BASIC_LLVMEXTRAS_H
+
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+
+/// A SetVector that does no allocations under the specified size
+///
+/// swift::SmallSetVector provides the old SmallSetVector semantics that allow
+/// storing types that don't have `operator==`.
+template <typename T, unsigned N>
+using SmallSetVector = llvm::SetVector<T, llvm::SmallVector<T, N>,
+      llvm::SmallDenseSet<T, N, llvm::DenseMapInfo<T>>>;
+
+} // namespace swift
+
+#endif // SWIFT_BASIC_LLVMEXTRAS_H

include/swift/Basic/LangOptions.h

@@ -32,7 +32,7 @@
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
+#include "llvm/TargetParser/Triple.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"

include/swift/Basic/MultiMapCache.h

@@ -16,6 +16,9 @@
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/None.h"
+#include "swift/Basic/STLExtras.h"
 
 namespace swift {
 
@@ -61,7 +64,8 @@ class MultiMapCache {
 
     // If we already have a cached value, just return the cached value.
     if (!iter.second) {
-      return iter.first->second.transform(
+
+      return swift::transform(iter.first->second,
           [&](std::tuple<unsigned, unsigned> startLengthRange) {
             return llvm::makeArrayRef(data).slice(
                 std::get<ArrayStartOffset>(startLengthRange),

include/swift/Basic/Program.h

@@ -14,6 +14,7 @@
 #define SWIFT_BASIC_PROGRAM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorOr.h"

include/swift/Basic/STLExtras.h

@@ -28,6 +28,7 @@
 #include <numeric>
 #include <type_traits>
 #include <unordered_set>
+#include <optional>
 
 namespace swift {
 
@@ -783,6 +784,17 @@ void emplace_back_all(VectorType &vector, ValueType &&value,
 template <class VectorType>
 void emplace_back_all(VectorType &vector) {}
 
+/// Apply a function to the value if present; otherwise return None.
+template <typename OptionalElement, typename Function>
+auto transform(const llvm::Optional<OptionalElement> &value,
+               const Function &operation)
+    -> llvm::Optional<decltype(operation(*value))> {
+
+  if (value) {
+    return operation(*value);
+  }
+  return llvm::None;
+}
 } // end namespace swift
 
 #endif // SWIFT_BASIC_STLEXTRAS_H