---

yaml
---
r: 278007
b: refs/heads/swift-5.1-old-llvm-branch
c: 7989d3f
h: refs/heads/master
i:
  278005: 2f7dfb9
  278003: a1fd251
  277999: a62e822

Author: gottesmm

[refs]

@@ -1241,7 +1241,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-01-24-a: b6f62823aa5010b2ae53f15f72a57
 refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e0
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
-refs/heads/swift-5.1-old-llvm-branch: 9b9d01ea5d3519e1b2c5bf8d03efdc2290eb2b7a
+refs/heads/swift-5.1-old-llvm-branch: 7989d3f48c98aa24222eb9b3b359b2c814f936d8
 refs/heads/swift-5.1-branch: 8060872acb4105d9655e020fe047e1ebcd77d0fb
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e

branches/swift-5.1-old-llvm-branch/cmake/modules/AddSwift.cmake

@@ -30,7 +30,11 @@ endfunction()
 # Compute the library subdirectory to use for the given sdk and
 # architecture, placing the result in 'result_var_name'.
 function(compute_library_subdir result_var_name sdk arch)
-  set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
+  if(sdk IN_LIST SWIFT_APPLE_PLATFORMS)
+    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}" PARENT_SCOPE)
+  else()
+    set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
+  endif()
 endfunction()
 
 function(_compute_lto_flag option out_var)
@@ -1156,6 +1160,8 @@ function(_add_swift_library_single target name)
   # Don't set PROPERTY COMPILE_FLAGS or LINK_FLAGS directly.
   set(c_compile_flags ${SWIFTLIB_SINGLE_C_COMPILE_FLAGS})
   set(link_flags ${SWIFTLIB_SINGLE_LINK_FLAGS})
+
+  set(library_search_subdir "${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}")
   set(library_search_directories
       "${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}"
       "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFTLIB_SINGLE_SUBDIR}"
@@ -1300,6 +1306,7 @@ function(_add_swift_library_single target name)
   if(target_static)
     set_property(TARGET "${target_static}" APPEND_STRING PROPERTY
         COMPILE_FLAGS " ${c_compile_flags}")
+    # FIXME: The fallback paths here are going to be dynamic libraries.
     set(library_search_directories
         "${SWIFTSTATICLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}"
         "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFTLIB_SINGLE_SUBDIR}"

branches/swift-5.1-old-llvm-branch/cmake/modules/SwiftSource.cmake

@@ -61,9 +61,7 @@ function(handle_swift_sources
   endif()
 
   if(swift_sources)
-    compute_library_subdir(SWIFTSOURCES_LIBRARY_SUBDIR
-      "${SWIFTSOURCES_SDK}" "${SWIFTSOURCES_ARCHITECTURE}")
-    set(objsubdir "/${SWIFTSOURCES_LIBRARY_SUBDIR}")
+    set(objsubdir "/${SWIFTSOURCES_SDK}/${SWIFTSOURCES_ARCHITECTURE}")
 
     file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}${objsubdir}")
 
@@ -255,6 +253,8 @@ function(_compile_swift_files
         "-nostdimport" "-parse-stdlib" "-module-name" "Swift")
     list(APPEND swift_flags "-Xfrontend" "-group-info-path"
                             "-Xfrontend" "${GROUP_INFO_JSON_FILE}")
+  else()
+    list(APPEND swift_flags "-module-name" "${SWIFTFILE_MODULE_NAME}")
   endif()
 
   # Force swift 5 mode for Standard Library.
@@ -313,19 +313,32 @@ function(_compile_swift_files
     list(APPEND swift_flags "-parse-as-library")
 
     set(module_base "${module_dir}/${SWIFTFILE_MODULE_NAME}")
+    if(SWIFTFILE_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+      set(specific_module_dir "${module_base}.swiftmodule")
+      set(module_base "${module_base}.swiftmodule/${SWIFTFILE_ARCHITECTURE}")
+    endif()
     set(module_file "${module_base}.swiftmodule")
+    set(module_doc_file "${module_base}.swiftdoc")
+
+    # FIXME: These don't really belong inside the swiftmodule, but there's not
+    # an obvious alternate place to put them.
     set(sib_file "${module_base}.Onone.sib")
     set(sibopt_file "${module_base}.O.sib")
     set(sibgen_file "${module_base}.sibgen")
-    set(module_doc_file "${module_base}.swiftdoc")
 
     if(SWIFT_ENABLE_PARSEABLE_MODULE_INTERFACES)
       set(interface_file "${module_base}.swiftinterface")
-      list(APPEND swift_flags "-emit-parseable-module-interface")
+      list(APPEND swift_flags
+          "-emit-parseable-module-interface-path" "${interface_file}")
     endif()
 
-    list(APPEND command_create_dirs
-        COMMAND "${CMAKE_COMMAND}" -E make_directory "${module_dir}")
+    if(SWIFTFILE_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+      list(APPEND command_create_dirs
+          COMMAND "${CMAKE_COMMAND}" -E make_directory "${specific_module_dir}")
+    else()
+      list(APPEND command_create_dirs
+          COMMAND "${CMAKE_COMMAND}" -E make_directory "${module_dir}")
+    endif()
 
     # If we have extra regexp flags, check if we match any of the regexps. If so
     # add the relevant flags to our swift_flags.
@@ -349,10 +362,15 @@ function(_compile_swift_files
     set(optional_arg "OPTIONAL")
   endif()
 
-  swift_install_in_component("${SWIFTFILE_INSTALL_IN_COMPONENT}"
-    FILES ${module_outputs}
-    DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/swift/${library_subdir}"
-    "${optional_arg}")
+  if(SWIFTFILE_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+    swift_install_in_component("${SWIFTFILE_INSTALL_IN_COMPONENT}"
+      DIRECTORY "${specific_module_dir}"
+      DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/swift/${library_subdir}")
+  else()
+    swift_install_in_component("${SWIFTFILE_INSTALL_IN_COMPONENT}"
+      FILES ${module_outputs}
+      DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/swift/${library_subdir}")
+  endif()
 
   set(line_directive_tool "${SWIFT_SOURCE_DIR}/utils/line-directive")
   set(swift_compiler_tool "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")

branches/swift-5.1-old-llvm-branch/docs/SIL.rst

@@ -2937,6 +2937,7 @@ is_escaping_closure
 ```````````````````
 
 ::
+
   sil-instruction ::= 'is_escaping_closure' sil-operand
 
   %1 = is_escaping_closure %0 : $@callee_guaranteed () -> ()
@@ -2948,6 +2949,7 @@ true if it is.
 
 copy_block
 ``````````
+
 ::
 
   sil-instruction :: 'copy_block' sil-operand
@@ -2960,6 +2962,7 @@ if the block is copied from the stack to the heap.
 
 copy_block_without_escaping
 ```````````````````````````
+
 ::
 
   sil-instruction :: 'copy_block_without_escaping' sil-operand 'withoutEscaping' sil-operand

branches/swift-5.1-old-llvm-branch/docs/StandardLibraryProgrammersManual.md

@@ -171,6 +171,65 @@ The standard library utilizes thread local storage (TLS) to cache expensive comp
 
 See [ThreadLocalStorage.swift](https://github.com/apple/swift/blob/master/stdlib/public/core/ThreadLocalStorage.swift) for more details.
 
+
+## Working with Resilience
+
+Maintaining ABI compatibility with previously released versions of the standard library makes things more complicated. This section details some of the extra rules to remember and patterns to use.
+
+### The Curiously Recursive Inlinable Switch Pattern (CRISP)
+
+When inlinable code switches over a non-frozen enum, it has to handle possible future cases (since it will be inlined into a module outside the standard library). You can see this in action with the implementation of `round(_:)` in FloatingPointTypes.swift.gyb, which takes a FloatingPointRoundingRule. It looks something like this:
+
+```swift
+@_transparent
+public mutating func round(_ rule: FloatingPointRoundingRule) {
+  switch rule {
+  case .toNearestOrAwayFromZero:
+    _value = Builtin.int_round_FPIEEE${bits}(_value)
+  case .toNearestOrEven:
+    _value = Builtin.int_rint_FPIEEE${bits}(_value)
+  // ...
+  @unknown default:
+    self._roundSlowPath(rule)
+  }
+}
+```
+
+Making `round(_:)` inlinable but still have a default case is an attempt to get the best of both worlds: if the rounding rule is known at compile time, the call will compile down to a single instruction in optimized builds; and if it dynamically turns out to be a new kind of rounding rule added in Swift 25 (e.g. `.towardFortyTwo`), there's a fallback function, `_roundSlowPath(_:)`, that can handle it.
+
+So what does `_roundSlowPath(_:)` look like? Well, it can't be inlinable, because that would defeat the purpose. It *could* just look like this:
+
+```swift
+@usableFromInline
+internal mutating func _roundSlowPath(_ rule: FloatingPointRoundingRule) {
+  switch rule {
+  case .toNearestOrAwayFromZero:
+    _value = Builtin.int_round_FPIEEE${bits}(_value)
+  case .toNearestOrEven:
+    _value = Builtin.int_rint_FPIEEE${bits}(_value)
+  // ...
+  }
+}
+```
+
+...i.e. exactly the same as `round(_:)` but with no `default` case. That's guaranteed to be up to date if any new cases are added in the future. But it seems a little silly, since it's duplicating code that's in `round(_:)`. We *could* omit cases that have always existed, but there's a better answer:
+
+```swift
+// Slow path for new cases that might have been inlined into an old
+// ABI-stable version of round(_:) called from a newer version. If this is
+// the case, this non-inlinable function will call into the _newer_ version
+// which _will_ support this rounding rule.
+@usableFromInline
+internal mutating func _roundSlowPath(_ rule: FloatingPointRoundingRule) {
+  self.round(rule)
+}
+```
+
+Because `_roundSlowPath(_:)` isn't inlinable, the version of `round(_:)` that gets called at run time will always be the version implemented in the standard library dylib. And since FloatingPointRoundingRule is *also* defined in the standard library, we know it'll never be out of sync with this version of `round(_:)`.
+
+Maybe some day we'll have special syntax in the language to say "call this method without allowing inlining" to get the same effect, but for now, this Curiously Recursive Inlinable Switch Pattern allows for safe inlining of switches over non-frozen enums with less boilerplate than you might otherwise have. Not none, but less.
+
+
 ## Productivity Hacks
 
 ### Be a Ninja

branches/swift-5.1-old-llvm-branch/lib/Frontend/CompilerInvocation.cpp

@@ -49,7 +49,8 @@ static void updateRuntimeLibraryPath(SearchPathOptions &SearchPathOpts,
   llvm::sys::path::append(LibPath, getPlatformNameForTriple(Triple));
   SearchPathOpts.RuntimeLibraryPath = LibPath.str();
 
-  llvm::sys::path::append(LibPath, swift::getMajorArchitectureName(Triple));
+  if (!Triple.isOSDarwin())
+    llvm::sys::path::append(LibPath, swift::getMajorArchitectureName(Triple));
   SearchPathOpts.RuntimeLibraryImportPath = LibPath.str();
 }
 

branches/swift-5.1-old-llvm-branch/lib/SILGen/SILGenPattern.cpp

@@ -2847,38 +2847,47 @@ void SILGenFunction::emitSwitchFallthrough(FallthroughStmt *S) {
 
   if (!caseStmt->hasBoundDecls()) {
     Cleanups.emitBranchAndCleanups(sharedDest, S);
-  } else {
-    // Generate branch args to pass along current vars to fallthrough case.
-    SILModule &M = F.getModule();
-    ArrayRef<CaseLabelItem> labelItems = caseStmt->getCaseLabelItems();
-    SmallVector<SILValue, 4> args;
-    SmallVector<VarDecl *, 4> expectedVarOrder;
-    labelItems[0].getPattern()->collectVariables(expectedVarOrder);
-    
-    for (auto *expected : expectedVarOrder) {
-      if (!expected->hasName())
+    return;
+  }
+
+  // Generate branch args to pass along current vars to fallthrough case.
+  SILModule &M = F.getModule();
+  ArrayRef<CaseLabelItem> labelItems = caseStmt->getCaseLabelItems();
+  SmallVector<SILValue, 4> args;
+  SmallVector<VarDecl *, 4> expectedVarOrder;
+  labelItems[0].getPattern()->collectVariables(expectedVarOrder);
+
+  for (auto *expected : expectedVarOrder) {
+    if (!expected->hasName())
+      continue;
+    for (auto var : VarLocs) {
+      auto varDecl = dyn_cast<VarDecl>(var.getFirst());
+      if (!varDecl || !varDecl->hasName() ||
+          varDecl->getName() != expected->getName()) {
         continue;
-      for (auto var : VarLocs) {
-        auto varDecl = dyn_cast<VarDecl>(var.getFirst());
-        if (varDecl && varDecl->hasName() && varDecl->getName() == expected->getName()) {
-          SILValue value = var.getSecond().value;
-
-          if (value->getType().isAddressOnly(M)) {
-            context->Emission.emitAddressOnlyInitialization(expected, value);
-          } else if (var.getSecond().box) {
-            auto &lowering = getTypeLowering(value->getType());
-            auto argValue = lowering.emitLoad(B, CurrentSILLoc, value, LoadOwnershipQualifier::Copy);
-            args.push_back(argValue);
-          } else {
-            auto argValue = B.emitCopyValueOperation(CurrentSILLoc, value);
-            args.push_back(argValue);
-          }
-          break;
-        }
       }
+
+      SILValue value = var.getSecond().value;
+
+      if (value->getType().isAddressOnly(M)) {
+        context->Emission.emitAddressOnlyInitialization(expected, value);
+        break;
+      }
+
+      if (var.getSecond().box) {
+        auto &lowering = getTypeLowering(value->getType());
+        auto argValue = lowering.emitLoad(B, CurrentSILLoc, value,
+                                          LoadOwnershipQualifier::Copy);
+        args.push_back(argValue);
+        break;
+      }
+
+      auto argValue = B.emitCopyValueOperation(CurrentSILLoc, value);
+      args.push_back(argValue);
+      break;
     }
-    Cleanups.emitBranchAndCleanups(sharedDest, S, args);
   }
+  Cleanups.emitBranchAndCleanups(sharedDest, S, args);
 }
 
 

branches/swift-5.1-old-llvm-branch/lib/Sema/CSApply.cpp

@@ -6677,7 +6677,24 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     break;
   }
 
-  default:
+#define SUGARED_TYPE(Name, Parent) case TypeKind::Name:
+#define BUILTIN_TYPE(Name, Parent) case TypeKind::Name:
+#define UNCHECKED_TYPE(Name, Parent) case TypeKind::Name:
+#define ARTIFICIAL_TYPE(Name, Parent) case TypeKind::Name:
+#define TYPE(Name, Parent)
+#include "swift/AST/TypeNodes.def"
+  case TypeKind::Error:
+  case TypeKind::InOut:
+  case TypeKind::Module:
+  case TypeKind::Enum:
+  case TypeKind::Struct:
+  case TypeKind::Protocol:
+  case TypeKind::ProtocolComposition:
+  case TypeKind::BoundGenericEnum:
+  case TypeKind::BoundGenericStruct:
+  case TypeKind::GenericFunction:
+  case TypeKind::GenericTypeParam:
+  case TypeKind::DependentMember:
     break;
   }
 
@@ -6687,7 +6704,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
   // Coercions from a type to an existential type.
   case TypeKind::ExistentialMetatype:
   case TypeKind::ProtocolComposition:
-  case TypeKind::Protocol: {
+  case TypeKind::Protocol:
     return coerceExistential(expr, toType, locator);
 
   // Coercion to Optional<T>.
@@ -6709,9 +6726,32 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     diagnoseOptionalInjection(result);
     return result;
   }
-  }
 
-  default:
+#define SUGARED_TYPE(Name, Parent) case TypeKind::Name:
+#define BUILTIN_TYPE(Name, Parent) case TypeKind::Name:
+#define UNCHECKED_TYPE(Name, Parent) case TypeKind::Name:
+#define ARTIFICIAL_TYPE(Name, Parent) case TypeKind::Name:
+#define TYPE(Name, Parent)
+#include "swift/AST/TypeNodes.def"
+  case TypeKind::Error:
+  case TypeKind::Module:
+  case TypeKind::Tuple:
+  case TypeKind::Enum:
+  case TypeKind::Struct:
+  case TypeKind::Class:
+  case TypeKind::BoundGenericClass:
+  case TypeKind::BoundGenericStruct:
+  case TypeKind::Metatype:
+  case TypeKind::DynamicSelf:
+  case TypeKind::PrimaryArchetype:
+  case TypeKind::OpenedArchetype:
+  case TypeKind::NestedArchetype:
+  case TypeKind::GenericTypeParam:
+  case TypeKind::DependentMember:
+  case TypeKind::Function:
+  case TypeKind::GenericFunction:
+  case TypeKind::LValue:
+  case TypeKind::InOut:
     break;
   }
 

branches/swift-5.1-old-llvm-branch/lib/Serialization/SerializedModuleLoader.cpp

@@ -301,10 +301,21 @@ SerializedModuleLoaderBase::findModule(AccessPathElem moduleID,
 
   // Search the runtime import path.
   isFramework = false;
-  return !findModuleFilesInDirectory(
-      moduleID, Ctx.SearchPathOpts.RuntimeLibraryImportPath,
-      moduleFilename.str(), moduleDocFilename.str(), moduleBuffer,
-      moduleDocBuffer);
+  currPath = Ctx.SearchPathOpts.RuntimeLibraryImportPath;
+  if (Ctx.LangOpts.Target.isOSDarwin()) {
+    // Apple platforms always use architecture-specific files within a
+    // .swiftmodule directory for the stdlib.
+    llvm::sys::path::append(currPath, moduleFilename.str());
+    return !findModuleFilesInDirectory(moduleID, currPath,
+                                       archFileNames.first,
+                                       archFileNames.second,
+                                       moduleBuffer, moduleDocBuffer);
+  }
+  // Non-Apple platforms always use single-architecture swiftmodules.
+  return !findModuleFilesInDirectory(moduleID, currPath,
+                                     moduleFilename.str(),
+                                     moduleDocFilename.str(),
+                                     moduleBuffer, moduleDocBuffer);
 }
 
 static std::pair<StringRef, clang::VersionTuple>