---

yaml
---
r: 348957
b: refs/heads/master
c: 54ec600
h: refs/heads/master
i:
  348955: 67d5a4e

Author: CodaFi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4bafc7718e3c155999806b0b3103088fffde4bdb
+refs/heads/master: 54ec600c11e3252011faa3ad5932b55e41372c83
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/cmake/modules/SwiftSource.cmake

@@ -333,6 +333,11 @@ function(_compile_swift_files
            "-emit-module-interface-path" "${interface_file}")
     endif()
 
+    if (NOT SWIFTFILE_IS_STDLIB_CORE)
+      list(APPEND swift_module_flags
+           "-Xfrontend" "-experimental-skip-non-inlinable-function-bodies")
+    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.
     if (SWIFT_EXPERIMENTAL_EXTRA_REGEXP_FLAGS OR SWIFT_EXPERIMENTAL_EXTRA_NEGATIVE_REGEXP_FLAGS)

trunk/lib/IRGen/LoadableByAddress.cpp

@@ -1426,6 +1426,20 @@ static void convertBBArgType(SILBuilder &argBuilder, SILType newSILType,
   }
 }
 
+static bool containsFunctionType(CanType ty) {
+  if (auto tuple = dyn_cast<TupleType>(ty)) {
+    for (auto elt : tuple.getElementTypes()) {
+      if (containsFunctionType(elt))
+        return true;
+    }
+    return false;
+  }
+  if (auto optionalType = ty.getOptionalObjectType()) {
+    return containsFunctionType(optionalType);
+  }
+  return isa<SILFunctionType>(ty);
+}
+
 void LoadableStorageAllocation::convertApplyResults() {
   for (auto &BB : *pass.F) {
     for (auto &II : BB) {
@@ -1450,16 +1464,7 @@ void LoadableStorageAllocation::convertApplyResults() {
         auto numFuncTy = llvm::count_if(origSILFunctionType->getResults(),
             [](const SILResultInfo &origResult) {
               auto resultStorageTy = origResult.getSILStorageType();
-              // Check if it is a function type
-              if (resultStorageTy.is<SILFunctionType>()) {
-                return true;
-              }
-              // Check if it is an optional function type
-              auto optionalType = resultStorageTy.getOptionalObjectType();
-              if (optionalType && optionalType.is<SILFunctionType>()) {
-                return true;
-              }
-              return false;
+              return containsFunctionType(resultStorageTy.getASTType());
             });
         assert(numFuncTy != 0 &&
                "Expected a SILFunctionType inside the result Type");

trunk/stdlib/public/runtime/HeapObject.cpp

@@ -72,6 +72,19 @@ static inline bool isValidPointerForNativeRetain(const void *p) {
 #endif
 }
 
+// Call the appropriate implementation of the `name` function, passing `args`
+// to the call. This checks for an override in the function pointer. If an
+// override is present, it calls that override. Otherwise it directly calls
+// the default implementation. This allows the compiler to inline the default
+// implementation and avoid the performance penalty of indirecting through
+// the function pointer in the common case.
+#define CALL_IMPL(name, args) do { \
+    if (SWIFT_UNLIKELY(_ ## name != _ ## name ## _)) \
+      return _ ## name args; \
+    return _ ## name ## _ args; \
+} while(0)
+
+
 static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                        size_t requiredSize,
                                        size_t requiredAlignmentMask) {
@@ -95,9 +108,7 @@ static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
 HeapObject *swift::swift_allocObject(HeapMetadata const *metadata,
                                      size_t requiredSize,
                                      size_t requiredAlignmentMask) {
-  if (SWIFT_UNLIKELY(_swift_allocObject != _swift_allocObject_))
-    return _swift_allocObject(metadata, requiredSize, requiredAlignmentMask);
-  return _swift_allocObject_(metadata, requiredSize, requiredAlignmentMask);
+  CALL_IMPL(swift_allocObject, (metadata, requiredSize, requiredAlignmentMask));
 }
 
 HeapObject *(*swift::_swift_allocObject)(HeapMetadata const *metadata,
@@ -305,9 +316,7 @@ static HeapObject *_swift_retain_(HeapObject *object) {
 }
 
 HeapObject *swift::swift_retain(HeapObject *object) {
-  if (SWIFT_UNLIKELY(_swift_retain != _swift_retain_))
-    return _swift_retain(object);
-  return _swift_retain_(object);
+  CALL_IMPL(swift_retain, (object));
 }
 
 HeapObject *(*swift::_swift_retain)(HeapObject *object) = _swift_retain_;
@@ -327,9 +336,7 @@ static HeapObject *_swift_retain_n_(HeapObject *object, uint32_t n) {
 }
 
 HeapObject *swift::swift_retain_n(HeapObject *object, uint32_t n) {
-  if (SWIFT_UNLIKELY(_swift_retain_n != _swift_retain_n_))
-    return _swift_retain_n(object, n);
-  return _swift_retain_n_(object, n);
+  CALL_IMPL(swift_retain_n, (object, n));
 }
 
 HeapObject *(*swift::_swift_retain_n)(HeapObject *object, uint32_t n) =
@@ -349,9 +356,7 @@ static void _swift_release_(HeapObject *object) {
 }
 
 void swift::swift_release(HeapObject *object) {
-  if (SWIFT_UNLIKELY(_swift_release != _swift_release_))
-    _swift_release(object);
-  _swift_release_(object);
+  CALL_IMPL(swift_release, (object));
 }
 
 void (*swift::_swift_release)(HeapObject *object) = _swift_release_;
@@ -369,9 +374,7 @@ static void _swift_release_n_(HeapObject *object, uint32_t n) {
 }
 
 void swift::swift_release_n(HeapObject *object, uint32_t n) {
-  if (SWIFT_UNLIKELY(_swift_release_n != _swift_release_n_))
-    return _swift_release_n(object, n);
-  return _swift_release_n_(object, n);
+  CALL_IMPL(swift_release_n, (object, n));
 }
 
 void (*swift::_swift_release_n)(HeapObject *object, uint32_t n) =
@@ -509,9 +512,7 @@ static HeapObject *_swift_tryRetain_(HeapObject *object) {
 }
 
 HeapObject *swift::swift_tryRetain(HeapObject *object) {
-  if (SWIFT_UNLIKELY(_swift_tryRetain != _swift_tryRetain_))
-    return _swift_tryRetain(object);
-  return _swift_tryRetain_(object);
+  CALL_IMPL(swift_tryRetain, (object));
 }
 
 HeapObject *(*swift::_swift_tryRetain)(HeapObject *object) = _swift_tryRetain_;

trunk/stdlib/toolchain/Compatibility50/ProtocolConformance.cpp

@@ -20,6 +20,7 @@
 #include "Overrides.h"
 #include "../../public/runtime/Private.h"
 #include "swift/Basic/Lazy.h"
+#include <dlfcn.h>
 #include <mach-o/dyld.h>
 #include <mach-o/getsect.h>
 #include <objc/runtime.h>
@@ -89,13 +90,25 @@ static void registerAddImageCallback(void *) {
   _dyld_register_func_for_add_image(addImageCallback);
 }
 
+static const Metadata *getObjCClassMetadata(const ClassMetadata *c) {
+  // Look up swift_getObjCClassMetadata dynamically. This handles the case
+  // where the main executable can't link against libswiftCore.dylib because
+  // it will be loaded dynamically from a location that isn't known at build
+  // time.
+  using FPtr = const Metadata *(*)(const ClassMetadata *);
+  FPtr func = SWIFT_LAZY_CONSTANT(
+    reinterpret_cast<FPtr>(dlsym(RTLD_DEFAULT, "swift_getObjCClassMetadata")));
+
+  return func(c);
+}
+
 // Clone of private helper swift::_swiftoverride_class_getSuperclass
 // for use in the override implementation.
 static const Metadata *_swift50override_class_getSuperclass(
                                                     const Metadata *theClass) {
   if (const ClassMetadata *classType = theClass->getClassObject()) {
     if (classHasSuperclass(classType))
-      return getMetadataForClass(classType->Superclass);
+      return getObjCClassMetadata(classType->Superclass);
   }
 
   if (const ForeignClassMetadata *foreignClassType

trunk/test/CMakeLists.txt

@@ -205,7 +205,7 @@ foreach(SDK ${SWIFT_SDKS})
 
     # NOTE create a stub BlocksRuntime library that can be used for the
     # reflection tests
-    file(WRITE ${test_bin_dir}/BlocksRuntime.c
+    file(WRITE ${test_bin_dir}/Inputs/BlocksRuntime.c
       "void
 #if defined(_WIN32)
 __declspec(dllexport)
@@ -220,7 +220,7 @@ _Block_release(void) { }\n")
       ARCHITECTURE ${ARCH}
       SDK ${SDK}
       INSTALL_IN_COMPONENT dev
-      ${test_bin_dir}/BlocksRuntime.c)
+      ${test_bin_dir}/Inputs/BlocksRuntime.c)
     set_target_properties(BlocksRuntimeStub${VARIANT_SUFFIX} PROPERTIES
       ARCHIVE_OUTPUT_DIRECTORY ${test_bin_dir}
       LIBRARY_OUTPUT_DIRECTORY ${test_bin_dir}

trunk/test/IRGen/big_types_corner_cases.swift

@@ -346,3 +346,11 @@ public extension sr8076_QueryHandler {
         return try body(query)
     }
 }
+
+public func foo() -> Optional<(a: Int?, b: Bool, c: (Int?)->BigStruct?)> {
+  return nil
+}
+
+public func dontAssert() {
+  let _ = foo()
+}

trunk/test/lit.cfg

@@ -178,8 +178,8 @@ config.test_format = swift_test.SwiftTest(coverage_mode=config.coverage_mode,
                                           execute_external=not use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files.
-config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.swiftinterface',
-                   '.test-sh']
+config.suffixes = ['.swift', '.ll', '.sil', '.gyb', '.m', '.c',
+                   '.swiftinterface', '.test-sh']
 
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent

trunk/test/stdlib/Compatibility50Linking.c

@@ -0,0 +1,13 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-clang %s -all_load %test-resource-dir/%target-sdk-name/libswiftCompatibility50.a -lobjc -o %t/main
+// RUN: %target-run %t/main
+// REQUIRES: objc_interop
+// REQUIRES: executable_test
+
+// The compatibility library needs to have no build-time dependencies on
+// libswiftCore so it can be linked into a program that doesn't link
+// libswiftCore, but will load it at runtime, such as xctest.
+//
+// Test this by linking it into a plain C program and making sure it builds.
+
+int main(void) {}