Update from upstream

Author: Azoy

CMakeLists.txt

@@ -207,6 +207,10 @@ option(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT
     "Whether to enable CrashReporter integration"
     FALSE)
 
+option(SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT
+    "Enable the Swift stable ABI's class marker bit"
+    FALSE)
+
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")
 

README.md

@@ -114,7 +114,7 @@ options such as building a Swift-compatible LLDB, building the Swift Package
 Manager, building for various platforms, running tests after builds, and more.
 
 There are two primary build systems to use: Xcode and Ninja. The Xcode build
-system allows you to work in Xcode.app, but Ninja is a bit faster and supports
+system allows you to work in Xcode, but Ninja is a bit faster and supports
 more environments.
 
 To build using Ninja, run:
@@ -143,7 +143,7 @@ information, see the inline help:
 #### Xcode
 
 To build using Xcode, specify the `--xcode` argument on any of the above commands.
-Xcode.app can be used to edit the Swift source code, but it is not currently
+Xcode can be used to edit the Swift source code, but it is not currently
 fully supported as a build environment for SDKs other than macOS. The generated
 Xcode project does not integrate with the test runner, but the tests can be run
 with the 'check-swift' target.
@@ -159,7 +159,7 @@ helps to save this directory as an environment variable for future use.
 
 #### Ninja
 
-Once the first build has completed, ninja can perform fast incremental builds of
+Once the first build has completed, Ninja can perform fast incremental builds of
 various products. These incremental builds are a big timesaver when developing
 and debugging.
 

benchmark/CMakeLists.txt

@@ -217,6 +217,20 @@ option(SWIFT_BENCHMARK_GENERATE_OPT_VIEW
   "Produce optimization view for benchmarks"
   FALSE)
 
+set(SWIFT_BENCHMARK_OPT_VIEWER "" CACHE FILEPATH
+  "Path to opt-viewer")
+
+if(SWIFT_BENCHMARK_OPT_VIEWER)
+  # If the path to the opt-viewer was specified manually and we have no access
+  # to the LLVM tree, assume we have the modules for the opt-viewer installed.
+  if(SWIFT_BENCHMARK_BUILT_STANDALONE)
+    set(LLVM_HAVE_OPT_VIEWER_MODULES 1)
+  endif()
+else()
+  set (SWIFT_BENCHMARK_OPT_VIEWER
+    "${LLVM_BUILD_MAIN_SRC_DIR}/tools/opt-viewer/opt-viewer.py")
+endif()
+
 # Options for other configurations
 set(BENCHOPTS_MULTITHREADED
     "-whole-module-optimization" "-num-threads" "4")

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -99,11 +99,10 @@ endfunction()
 function(add_opt_view opt_view_main_dir, module_name, opt_view_dir_out)
   set(opt_view_dir "${opt_view_main_dir}/${module_name}")
   set(opt_record "${objdir}/${module_name}.opt.yaml")
-  set(opt_viewer "${LLVM_BUILD_MAIN_SRC_DIR}/tools/opt-viewer/opt-viewer.py")
   add_custom_command(
     OUTPUT ${opt_view_dir}
     DEPENDS "${objfile}"
-    COMMAND ${opt_viewer} ${opt_record} "-o" ${opt_view_dir})
+    COMMAND ${SWIFT_BENCHMARK_OPT_VIEWER} ${opt_record} "-o" ${opt_view_dir})
   set(${opt_view_dir_out} ${opt_view_dir} PARENT_SCOPE)
 endfunction()
 
@@ -214,9 +213,6 @@ function (swift_benchmark_compile_archopts)
 
   set(opt_view_main_dir)
   if(SWIFT_BENCHMARK_GENERATE_OPT_VIEW AND LLVM_HAVE_OPT_VIEWER_MODULES)
-    precondition(SWIFT_BENCHMARK_BUILT_STANDALONE NEGATE
-      "Opt-viewer is not supported when running the benchmarks outside the Swift tree")
-
     if(NOT ${optflag} STREQUAL "Onone" AND "${bench_flags}" MATCHES "-whole-module.*")
       list(APPEND common_options "-save-optimization-record")
       set(opt_view_main_dir "${objdir}/opt-view")

benchmark/single-source/ArraySetElement.swift

@@ -18,7 +18,7 @@ import TestsUtils
 public var ArraySetElement = BenchmarkInfo(
   name: "ArraySetElement",
   runFunction: run_ArraySetElement,
-  tags: [.runtime, .cpubench]
+  tags: [.runtime, .cpubench, .unstable]
 )
 
 // This is an effort to defeat isUniquelyReferenced optimization. Ideally

benchmark/single-source/Exclusivity.swift

@@ -35,7 +35,7 @@ public let Exclusivity = [
   BenchmarkInfo(
     name: "ExclusivityInMatSet",
     runFunction: run_accessInMatSet,
-    tags: [.runtime, .cpubench]
+    tags: [.runtime, .cpubench, .unstable]
   ),
   // At -Onone
   // 25% swift_release

cmake/modules/AddSwift.cmake

@@ -856,6 +856,9 @@ function(_add_swift_library_single target name)
   if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
     swift_windows_include_for_arch(${SWIFTLIB_SINGLE_ARCHITECTURE} SWIFTLIB_INCLUDE)
     target_include_directories("${target}" SYSTEM PRIVATE ${SWIFTLIB_INCLUDE})
+    set_target_properties(${target}
+                          PROPERTIES
+                            CXX_STANDARD 14)
   endif()
 
   if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS" AND NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")

docs/ABI/Mangling.rst

@@ -175,9 +175,13 @@ Entities
   static ::= 'Z'
   curry-thunk ::= 'Tc'
 
+  label-list ::= empty-list            // represents complete absence of parameter labels
+  label-list ::= ('_' | identifier)*   // '_' is inserted as placeholder for empty label,
+                                       // since the number of labels should match the number of parameters
+
   // The leading type is the function type
-  entity-spec ::= type file-discriminator? 'fC'      // allocating constructor
-  entity-spec ::= type file-discriminator? 'fc'      // non-allocating constructor
+  entity-spec ::= label-list type file-discriminator? 'fC'      // allocating constructor
+  entity-spec ::= label-list type file-discriminator? 'fc'      // non-allocating constructor
   entity-spec ::= type 'fU' INDEX            // explicit anonymous closure expression
   entity-spec ::= type 'fu' INDEX            // implicit anonymous closure
   entity-spec ::= 'fA' INDEX                 // default argument N+1 generator
@@ -189,11 +193,11 @@ Entities
   entity-spec ::= 'Tv' NATURAL               // outlined global variable (from context function)
   entity-spec ::= 'Te' bridge-spec           // outlined objective c method call
 
-  entity-spec ::= decl-name function-signature generic-signature? 'F'    // function
-  entity-spec ::= type file-discriminator? 'i' ACCESSOR                  // subscript
-  entity-spec ::= decl-name type 'v' ACCESSOR                            // variable
-  entity-spec ::= decl-name type 'fp'                // generic type parameter
-  entity-spec ::= decl-name type 'fo'                // enum element (currently not used)
+  entity-spec ::= decl-name label-list function-signature generic-signature? 'F'    // function
+  entity-spec ::= label-list type file-discriminator? 'i' ACCESSOR                  // subscript
+  entity-spec ::= decl-name label-list? type 'v' ACCESSOR                           // variable
+  entity-spec ::= decl-name type 'fp'                                               // generic type parameter
+  entity-spec ::= decl-name type 'fo'                                               // enum element (currently not used)
 
   ACCESSOR ::= 'm'                           // materializeForSet
   ACCESSOR ::= 's'                           // setter
@@ -351,7 +355,8 @@ Types
   function-signature ::= params-type params-type throws? // results and parameters
 
   params-type := type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
-                                             // with optional inout convention, shared convention
+                                             // with optional inout convention, shared convention. parameters don't have labels,
+                                             // they are mangled separately as part of the entity.
   params-type := empty-list                  // shortcut for no parameters
 
   throws ::= 'K'                             // 'throws' annotation on function types

docs/ErrorHandlingRationale.rst

@@ -577,9 +577,9 @@ be able to recognize specific classes of error, but libraries
 generally want to reserve flexibility about the exact kind of error
 they produce, and so many errors just end up falling into broad
 buckets.  Different libraries end up with their own library-specific
-general error classes, and exceptions list end up just restating the
+general error classes, and exception lists end up just restating the
 library's own dependencies or wrapping the underlying errors in ways
-that loses critical information.
+that lose critical information.
 
 
 Tradeoffs of typed propagation
@@ -799,7 +799,7 @@ significantly for the common case of frames that just need to run some
 clean-ups before propagating the error further.  It may even
 completely eliminate the need for a landing pad.
 
-The ObjC/C++ exceptions system on iOS/ARM32 is kindof like that
+The ObjC/C++ exceptions system on iOS/ARM32 is kind of like that
 hybrid.  Propagation and clean-up code is explicit in the function,
 but the registered context includes the "personality" information from
 the unwinding tables, which makes the decision whether to land at the
@@ -1096,7 +1096,7 @@ exceptions.
 
 Objective-C exceptions are *mostly* only used for unrecoverable
 conditions, akin to what I called "failures" above.  There are a few
-major exceptions to this rule, where APIs that do use exceptions to
+major exceptions to this rule, where APIs do use exceptions to
 report errors.
 
 Instead, Objective-C mostly relies on manual propagation,
@@ -1134,7 +1134,7 @@ failures in our scheme; essentially, Java attempts to promote a fully
 statically-enforced model where truly catastrophic problems can still
 be handled when necessary.  Unfortunately, these motivations don't
 seem to have been communicated very well to developers, and the result
-is kindof a mess.
+is kind of a mess.
 
 Java allows methods to be very specific about the kinds of exception
 they throw.  In my experience, exceptions tend to fall into two
@@ -1420,9 +1420,9 @@ It is valuable to be able to overload higher-order functions based on
 whether an argument function throws; it is easy to imagine algorithms
 that can be implemented more efficiently if they do not need to worry
 about exceptions.  (We do not, however, particularly want to encourage
-a pattern of duplicating This is straightforward if the primary
+a pattern of duplicating. This is straightforward if the primary
 type-checking pass is able to reliably decide whether a function value
-can throw.
+can throw.)
 
 Typed propagation checking can generally be performed in a secondary
 pass over a type-checked function body: if a function is not permitted
@@ -1509,7 +1509,7 @@ code using the protocol to deal with probably-spurious errors, or
 aggressively forbid them, and thus forbid conformances by types whose
 operations naturally throw.
 
-There are several different ways we could approach this problem, but
+There are several different ways we could approach this problem, and
 after some investigation I feel confident that they're workable.
 Unfortunately, they are clearly out-of-scope for the first release.
 For now, the standard library should provide protocols that cannot

docs/Runtime.md

@@ -314,8 +314,9 @@ runtime.
 000000000001e620 T _swift_allocateGenericValueMetadata
 0000000000022be0 T _swift_initClassMetadata_UniversalStrategy
 000000000001c100 T _swift_initEnumMetadataMultiPayload
-000000000001bd60 T _swift_initEnumValueWitnessTableSinglePayload
-0000000000022a20 T _swift_initStructMetadata_UniversalStrategy
+000000000001bd60 T _swift_initEnumMetadataSingleCase
+000000000001bd60 T _swift_initEnumMetadataSinglePayload
+0000000000022a20 T _swift_initStructMetadata
 0000000000024230 T _swift_initializeSuperclass
 0000000000028b60 T _swift_instantiateObjCClass
 ```

include/swift/ABI/MetadataValues.h

@@ -86,12 +86,16 @@ inline DynamicCastFlags &operator|=(DynamicCastFlags &a, DynamicCastFlags b) {
 }
 
 /// Swift class flags.
+/// These flags are valid only when isTypeMetadata().
+/// When !isTypeMetadata() these flags will collide with other Swift ABIs.
 enum class ClassFlags : uint32_t {
-  /// Is this a Swift 1 class?
-  IsSwift1 = 0x1,
+  /// Is this a Swift class from the Darwin pre-stable ABI?
+  /// This bit is clear in stable ABI Swift classes.
+  /// The Objective-C runtime also reads this bit.
+  IsSwiftPreStableABI = 0x1,
 
-  /// Does this class use Swift 1.0 refcounting?
-  UsesSwift1Refcounting = 0x2,
+  /// Does this class use Swift refcounting?
+  UsesSwiftRefcounting = 0x2,
 
   /// Has this class a custom name, specified with the @objc attribute?
   HasCustomObjCName = 0x4
@@ -747,6 +751,62 @@ static inline bool isWarningOnly(ExclusivityFlags flags) {
   return uintptr_t(flags) & uintptr_t(ExclusivityFlags::WarningOnly);
 }
 
+/// Flags for struct layout.
+enum class StructLayoutFlags : uintptr_t {
+  /// Reserve space for 256 layout algorithms.
+  AlgorithmMask     = 0xff,
+
+  /// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
+  Swift5Algorithm   = 0x00,
+
+  /// Is the value-witness table mutable in place, or does layout need to
+  /// clone it?
+  IsVWTMutable      = 0x100,
+};
+static inline StructLayoutFlags operator|(StructLayoutFlags lhs,
+                                          StructLayoutFlags rhs) {
+  return StructLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
+}
+static inline StructLayoutFlags &operator|=(StructLayoutFlags &lhs,
+                                            StructLayoutFlags rhs) {
+  return (lhs = (lhs | rhs));
+}
+static inline StructLayoutFlags getLayoutAlgorithm(StructLayoutFlags flags) {
+  return StructLayoutFlags(uintptr_t(flags)
+                             & uintptr_t(StructLayoutFlags::AlgorithmMask));
+}
+static inline bool isValueWitnessTableMutable(StructLayoutFlags flags) {
+  return uintptr_t(flags) & uintptr_t(StructLayoutFlags::IsVWTMutable);
+}
+
+/// Flags for enum layout.
+enum class EnumLayoutFlags : uintptr_t {
+  /// Reserve space for 256 layout algorithms.
+  AlgorithmMask     = 0xff,
+
+  /// The ABI baseline algorithm, i.e. the algorithm implemented in Swift 5.
+  Swift5Algorithm   = 0x00,
+
+  /// Is the value-witness table mutable in place, or does layout need to
+  /// clone it?
+  IsVWTMutable      = 0x100,
+};
+static inline EnumLayoutFlags operator|(EnumLayoutFlags lhs,
+                                        EnumLayoutFlags rhs) {
+  return EnumLayoutFlags(uintptr_t(lhs) | uintptr_t(rhs));
+}
+static inline EnumLayoutFlags &operator|=(EnumLayoutFlags &lhs,
+                                          EnumLayoutFlags rhs) {
+  return (lhs = (lhs | rhs));
+}
+static inline EnumLayoutFlags getLayoutAlgorithm(EnumLayoutFlags flags) {
+  return EnumLayoutFlags(uintptr_t(flags)
+                           & uintptr_t(EnumLayoutFlags::AlgorithmMask));
+}
+static inline bool isValueWitnessTableMutable(EnumLayoutFlags flags) {
+  return uintptr_t(flags) & uintptr_t(EnumLayoutFlags::IsVWTMutable);
+}
+
 } // end namespace swift
 
 #endif /* SWIFT_ABI_METADATAVALUES_H */

include/swift/AST/ASTContext.h

@@ -482,8 +482,8 @@ class ASTContext {
   FuncDecl *getEqualIntDecl() const;
 
   /// Retrieve the declaration of
-  /// Swift._mixForSynthesizedHashValue (Int, Int) -> Int.
-  FuncDecl *getMixForSynthesizedHashValueDecl() const;
+  /// Swift._combineHashValues(Int, Int) -> Int.
+  FuncDecl *getCombineHashValuesDecl() const;
 
   /// Retrieve the declaration of Swift._mixInt(Int) -> Int.
   FuncDecl *getMixIntDecl() const;

include/swift/AST/ASTMangler.h

@@ -187,6 +187,7 @@ class ASTMangler : public Mangler {
 
   void appendAnyGenericType(const GenericTypeDecl *decl);
 
+  void appendFunction(AnyFunctionType *fn, bool isFunctionMangling = false);
   void appendFunctionType(AnyFunctionType *fn);
 
   void appendFunctionSignature(AnyFunctionType *fn);

include/swift/AST/Builtins.h

@@ -99,7 +99,8 @@ ValueDecl *getBuiltinValueDecl(ASTContext &Context, Identifier Name);
 StringRef getBuiltinName(BuiltinValueKind ID);
 
 /// \brief The information identifying the builtin - its kind and types.
-struct BuiltinInfo {
+class BuiltinInfo {
+public:
   BuiltinValueKind ID;
   SmallVector<Type, 4> Types;
   bool isReadNone() const;