Merge remote-tracking branch 'origin/swift-4.1-branch' into swift-5.0-branch

Author: bob-wilson

include/swift/Option/Options.td

@@ -619,6 +619,14 @@ def whole_module_optimization : Flag<["-"], "whole-module-optimization">,
   HelpText<"Optimize input files together instead of individually">,
   Flags<[FrontendOption, NoInteractiveOption]>;
 
+def enable_batch_mode : Flag<["-"], "enable-batch-mode">,
+  Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
+  HelpText<"Enable combining frontend jobs into batches">;
+
+def disable_batch_mode : Flag<["-"], "disable-batch-mode">,
+  Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
+  HelpText<"Disable combining frontend jobs into batches">;
+
 def wmo : Flag<["-"], "wmo">, Alias<whole_module_optimization>,
   Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>;
 

include/swift/SIL/TypeLowering.h

@@ -830,7 +830,8 @@ class TypeConverter {
   /// The ABI compatible relation is not symmetric on function types -- while
   /// T and T! are both subtypes of each other, a calling convention conversion
   /// of T! to T always requires a thunk.
-  ABIDifference checkForABIDifferences(SILType type1, SILType type2);
+  ABIDifference checkForABIDifferences(SILType type1, SILType type2,
+                                       bool thunkOptionals = true);
 
   /// \brief Same as above but for SIL function types.
   ABIDifference checkFunctionForABIDifferences(SILFunctionType *fnTy1,

lib/IRGen/GenBuiltin.cpp

@@ -198,6 +198,11 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   // At that stage, the function name GV used by the profiling pass is hidden.
   // Fix the intrinsic call here by pointing it to the correct GV.
   if (IID == llvm::Intrinsic::instrprof_increment) {
+    // If we import profiling intrinsics from a swift module but profiling is
+    // not enabled, ignore the increment.
+    if (!IGF.getSILModule().getOptions().GenerateProfile)
+      return;
+
     // Extract the PGO function name.
     auto *NameGEP = cast<llvm::User>(args.claimNext());
     auto *NameGV = dyn_cast<llvm::GlobalVariable>(NameGEP->stripPointerCasts());

lib/IRGen/LoadableByAddress.cpp

@@ -79,24 +79,16 @@ static bool shouldTransformFunctionType(GenericEnvironment *env,
                                         CanSILFunctionType fnType,
                                         irgen::IRGenModule &IGM);
 
+static SILParameterInfo getNewParameter(GenericEnvironment *env,
+                                        SILParameterInfo param,
+                                        irgen::IRGenModule &IGM);
+
 static bool shouldTransformParameter(GenericEnvironment *env,
                                      SILParameterInfo param,
                                      irgen::IRGenModule &IGM) {
-  SILType storageType = param.getSILStorageType();
-
-  // FIXME: only function types and not recursively-transformable types?
-  if (auto fnType = storageType.getAs<SILFunctionType>())
-    return shouldTransformFunctionType(env, fnType, IGM);
 
-  switch (param.getConvention()) {
-  case ParameterConvention::Indirect_In_Guaranteed:
-  case ParameterConvention::Indirect_Inout:
-  case ParameterConvention::Indirect_InoutAliasable:
-  case ParameterConvention::Indirect_In:
-    return false;
-  default:
-    return isLargeLoadableType(env, storageType, IGM);
-  }
+  auto newParam = getNewParameter(env, param, IGM);
+  return (param != newParam);
 }
 
 static bool shouldTransformFunctionType(GenericEnvironment *env,
@@ -2464,6 +2456,10 @@ void LoadableByAddress::run() {
           if (isa<ProjectBlockStorageInst>(dest)) {
             storeToBlockStorageInstrs.insert(SI);
           }
+        } else if (auto *PAI = dyn_cast<PartialApplyInst>(&I)) {
+          if (modApplies.count(PAI) == 0) {
+            modApplies.insert(PAI);
+          }
         }
       }
     }

lib/SIL/TypeLowering.cpp

@@ -2267,7 +2267,8 @@ TypeConverter::getLoweredLocalCaptures(AnyFunctionRef fn) {
 /// Given that type1 is known to be a subtype of type2, check if the two
 /// types have the same calling convention representation.
 TypeConverter::ABIDifference
-TypeConverter::checkForABIDifferences(SILType type1, SILType type2) {
+TypeConverter::checkForABIDifferences(SILType type1, SILType type2,
+                                      bool thunkOptionals) {
   // Unwrap optionals, but remember that we did.
   bool type1WasOptional = false;
   bool type2WasOptional = false;
@@ -2280,15 +2281,23 @@ TypeConverter::checkForABIDifferences(SILType type1, SILType type2) {
     type2 = object;
   }
 
-  // Forcing IUOs always requires a thunk.
-  if (type1WasOptional && !type2WasOptional)
-    return ABIDifference::NeedsThunk;
-  
-  // Except for the above case, we should not be making a value less optional.
+  bool optionalityChange;
+  if (thunkOptionals) {
+    // Forcing IUOs always requires a thunk.
+    if (type1WasOptional && !type2WasOptional)
+      return ABIDifference::NeedsThunk;
 
-  // If we're introducing a level of optionality, only certain types are
-  // ABI-compatible -- check below.
-  bool optionalityChange = (!type1WasOptional && type2WasOptional);
+    // Except for the above case, we should not be making a value less optional.
+    
+    // If we're introducing a level of optionality, only certain types are
+    // ABI-compatible -- check below.
+    optionalityChange = (!type1WasOptional && type2WasOptional);
+  } else {
+    // We haven't implemented codegen for optional thunking at all levels
+    // (particularly objc_blocks at depth). Just accept ABI compatibility
+    // in either direction in these cases.
+    optionalityChange = type1WasOptional != type2WasOptional;
+  }
 
   // If the types are identical and there was no optionality change,
   // we're done.
@@ -2393,7 +2402,8 @@ TypeConverter::checkFunctionForABIDifferences(SILFunctionType *fnTy1,
       return ABIDifference::NeedsThunk;
 
     if (checkForABIDifferences(result1.getSILStorageType(),
-                               result2.getSILStorageType())
+                             result2.getSILStorageType(),
+              /*thunk iuos*/ fnTy1->getLanguage() == SILFunctionLanguage::Swift)
         != ABIDifference::Trivial)
       return ABIDifference::NeedsThunk;
   }
@@ -2408,7 +2418,8 @@ TypeConverter::checkFunctionForABIDifferences(SILFunctionType *fnTy1,
       return ABIDifference::NeedsThunk;
 
     if (checkForABIDifferences(error1.getSILStorageType(),
-                               error2.getSILStorageType())
+                               error2.getSILStorageType(),
+              /*thunk iuos*/ fnTy1->getLanguage() == SILFunctionLanguage::Swift)
         != ABIDifference::Trivial)
       return ABIDifference::NeedsThunk;
   }
@@ -2424,7 +2435,8 @@ TypeConverter::checkFunctionForABIDifferences(SILFunctionType *fnTy1,
     std::swap(param1, param2);
 
     if (checkForABIDifferences(param1.getSILStorageType(),
-                               param2.getSILStorageType())
+                               param2.getSILStorageType(),
+              /*thunk iuos*/ fnTy1->getLanguage() == SILFunctionLanguage::Swift)
         != ABIDifference::Trivial)
       return ABIDifference::NeedsThunk;
   }

lib/SILGen/SILGenExpr.cpp

@@ -2773,12 +2773,13 @@ static SILValue emitMetatypeOfDelegatingInitExclusivelyBorrowedSelf(
   auto *vd = cast<ParamDecl>(dre->getDecl());
   ManagedValue selfValue;
 
+  Scope S(SGF, loc);
+  Optional<FormalEvaluationScope> FES;
   // If we have not exclusively borrowed self, we need to do so now.
   if (SGF.SelfInitDelegationState == SILGenFunction::WillExclusiveBorrowSelf) {
     // We need to use a full scope here to ensure that any underlying
     // "normal cleanup" borrows are cleaned up.
-    Scope S(SGF, loc);
-    selfValue = S.popPreservingValue(SGF.emitRValueAsSingleValue(dre));
+    selfValue = SGF.emitRValueAsSingleValue(dre);
   } else {
     // If we already exclusively borrowed self, then we need to emit self
     // using formal evaluation primitives.
@@ -2788,6 +2789,7 @@ static SILValue emitMetatypeOfDelegatingInitExclusivelyBorrowedSelf(
     // This needs to be inlined since there is a Formal Evaluation Scope
     // in emitRValueForDecl that causing any borrow for this LValue to be
     // popped too soon.
+    FES.emplace(SGF);
     selfValue =
         SGF.emitLValueForDecl(dre, vd, dre->getType()->getCanonicalType(),
                               AccessKind::Read, dre->getAccessSemantics());
@@ -2796,9 +2798,7 @@ static SILValue emitMetatypeOfDelegatingInitExclusivelyBorrowedSelf(
                        selfValue.getLValueAddress(), ctx)
                     .getAsSingleValue(SGF, loc);
   }
-  assert(selfValue && !selfValue.hasCleanup());
 
-  // Check if we need to perform a conversion here.
   return SGF.B.createValueMetatype(loc, metaTy, selfValue.getValue());
 }
 
@@ -2814,7 +2814,6 @@ SILValue SILGenFunction::emitMetatypeOfValue(SILLocation loc, Expr *baseExpr) {
                                   SGFContext::AllowImmediatePlusZero).getValue();
     return B.createExistentialMetatype(loc, metaTy, base);
   }
-
   SILType metaTy = getLoweredLoadableType(CanMetatypeType::get(baseTy));
   // If the lowered metatype has a thick representation, we need to derive it
   // dynamically from the instance.
@@ -2836,7 +2835,6 @@ SILValue SILGenFunction::emitMetatypeOfValue(SILLocation loc, Expr *baseExpr) {
     return S.popPreservingValue(B.createValueMetatype(loc, metaTy, base))
         .getValue();
   }
-  
   // Otherwise, ignore the base and return the static thin metatype.
   emitIgnoredExpr(baseExpr);
   return B.createMetatype(loc, metaTy);

test/IRGen/big_types_corner_cases.swift

@@ -1,4 +1,5 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -enable-large-loadable-types %s -emit-ir | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
+// REQUIRES: optimized_stdlib
 // UNSUPPORTED: resilient_stdlib
 
 public struct BigStruct {
@@ -205,3 +206,17 @@ func bigStructGet() -> BigStruct {
 public func testGetFunc() {
   let testGetPtr: @convention(thin) () -> BigStruct = bigStructGet
 }
+
+// CHECK-LABEL: define{{( protected)?}} hidden swiftcc void @_T022big_types_corner_cases7TestBigC4testyyF(%T22big_types_corner_cases7TestBigC* swiftself)
+// CHECK: [[CALL1:%.*]] = call %swift.type* @_T0Sayy22big_types_corner_cases9BigStructVcSgGMa
+// CHECK: [[CALL2:%.*]] = call i8** @_T0Sayy22big_types_corner_cases9BigStructVcSgGSayxGs10CollectionsWl
+// CHECK:  call swiftcc void @_T0s10CollectionPsE5index5IndexQzSgSb7ElementQzKc5where_tKF(%TSq.0* noalias nocapture sret %10, i8* bitcast (i1 (%T22big_types_corner_cases9BigStructVytIegir_Sg*, %swift.refcounted*, %swift.error**)* @_T022big_types_corner_cases9BigStructVIegy_SgSbs5Error_pIgxdzo_ACytIegir_SgSbsAE_pIgidzo_TRTA to i8*), %swift.refcounted* %7, %swift.type* %11, i8** [[CALL2]]
+// CHECK: ret void
+class TestBig {
+    typealias Handler = (BigStruct) -> Void
+
+    func test() {
+        let arr = [Handler?]()
+        let d = arr.index(where: { _ in true })
+    }
+}

test/IRGen/coverage_ignored.swift

@@ -0,0 +1,7 @@
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -profile-generate -emit-sil -o %t.sil
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -emit-ir -o - | %FileCheck %s
+
+// CHECK-NOT: llvm.instrprof
+// CHECK-NOT: profc
+func foo() {}
+foo()

test/SILGen/Inputs/objc_bridged_block_optionality_diff.h

@@ -0,0 +1,8 @@
+@import Foundation;
+
+#pragma clang assume_nonnull begin
+typedef void (^HandlerBlock)(NSString *(^message)(void));
+#pragma clang assume_nonnull end
+
+/// Default handler for logging.
+extern HandlerBlock TheHandlerBlock;

test/SILGen/metatype_in_init_delegation.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -emit-silgen -verify %s
+// REQUIRES: objc_interop
+
+import Foundation
+import CoreData
+
+@available(macOS 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *)
+class Foo : NSManagedObject {
+  convenience init(context: NSManagedObjectContext, value: Int) {
+    self.init(entity: type(of: self).entity(), insertInto: context)
+  }
+}

test/SILGen/objc_bridged_block_optionality_diff.swift

@@ -0,0 +1,6 @@
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-silgen %s -import-objc-header %S/Inputs/objc_bridged_block_optionality_diff.h -verify
+// REQUIRES: objc_interop
+import Foundation
+
+TheHandlerBlock = { x in () }
+