SILGen: Always use minimal resilience expansion for the calling convention

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -5985,20 +5985,19 @@ ArgumentSource SILGenFunction::prepareAccessorBaseArg(SILLocation loc,
   return Preparer.prepare();
 }
 
-static void collectFakeIndexParameters(SILGenModule &SGM,
+static void collectFakeIndexParameters(SILGenFunction &SGF,
                                        CanType substType,
                                     SmallVectorImpl<SILParameterInfo> &params) {
   if (auto tuple = dyn_cast<TupleType>(substType)) {
     for (auto substEltType : tuple.getElementTypes())
-      collectFakeIndexParameters(SGM, substEltType, params);
+      collectFakeIndexParameters(SGF, substEltType, params);
     return;
   }
 
   // Use conventions that will produce a +1 value.
-  auto &tl = SGM.Types.getTypeLowering(substType,
-                                       ResilienceExpansion::Minimal);
+  auto &tl = SGF.getTypeLowering(substType);
   ParameterConvention convention;
-  if (tl.isFormallyPassedIndirectly()) {
+  if (tl.isAddressOnly()) {
     convention = ParameterConvention::Indirect_In;
   } else if (tl.isTrivial()) {
     convention = ParameterConvention::Direct_Unowned;
@@ -6019,7 +6018,7 @@ static void emitPseudoFunctionArguments(SILGenFunction &SGF,
   SmallVector<SILParameterInfo, 4> substParamTys;
   for (auto substParam : substParams) {
     auto substParamType = substParam.getParameterType()->getCanonicalType();
-    collectFakeIndexParameters(SGF.SGM, substParamType, substParamTys);
+    collectFakeIndexParameters(SGF, substParamType, substParamTys);
   }
 
   SmallVector<ManagedValue, 4> argValues;

lib/SILGen/SILGenBridging.cpp

@@ -1370,6 +1370,15 @@ static SILFunctionType *emitObjCThunkArguments(SILGenFunction &SGF,
                         /*isCallResult*/ true);
     SILValue argValue;
 
+    // This can happen if the value is resilient in the calling convention
+    // but not resilient locally.
+    if (nativeInputs[i].isFormalIndirect() &&
+        !native.getType().isAddress()) {
+      auto buf = SGF.emitTemporaryAllocation(loc, native.getType());
+      native.forwardInto(SGF, loc, buf);
+      native = SGF.emitManagedBufferWithCleanup(buf);
+    }
+
     if (nativeInputs[i].isConsumed()) {
       argValue = native.forward(SGF);
     } else if (nativeInputs[i].isGuaranteed()) {

lib/SILGen/SILGenConstructor.cpp

@@ -52,6 +52,7 @@ static SILValue emitConstructorMetatypeArg(SILGenFunction &SGF,
   return SGF.AllocatorMetatype;
 }
 
+// FIXME: Consolidate this with SILGenProlog
 static RValue emitImplicitValueConstructorArg(SILGenFunction &SGF,
                                               SILLocation loc,
                                               CanType interfaceType,
@@ -73,14 +74,26 @@ static RValue emitImplicitValueConstructorArg(SILGenFunction &SGF,
                                AC.getIdentifier("$implicit_value"),
                                DC);
   VD->setInterfaceType(interfaceType);
-  SILFunctionArgument *arg =
-      SGF.F.begin()->createFunctionArgument(SGF.getLoweredType(type), VD);
+
+  auto argType = SGF.SGM.Types.getLoweredType(type,
+                                              ResilienceExpansion::Minimal);
+  auto *arg = SGF.F.begin()->createFunctionArgument(argType, VD);
   ManagedValue mvArg;
   if (arg->getArgumentConvention().isOwnedConvention()) {
     mvArg = SGF.emitManagedRValueWithCleanup(arg);
   } else {
     mvArg = ManagedValue::forUnmanaged(arg);
   }
+
+  // This can happen if the value is resilient in the calling convention
+  // but not resilient locally.
+  if (argType.isLoadable(SGF.SGM.M) && argType.isAddress()) {
+    if (mvArg.isPlusOne(SGF))
+      mvArg = SGF.B.createLoadTake(loc, mvArg);
+    else
+      mvArg = SGF.B.createLoadBorrow(loc, mvArg);
+  }
+
   return RValue(SGF, loc, type, mvArg);
 }
 
@@ -91,9 +104,8 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
   // FIXME: Handle 'self' along with the other arguments.
   auto *paramList = ctor->getParameters();
   auto *selfDecl = ctor->getImplicitSelfDecl();
-  auto selfTyCan = selfDecl->getType();
-  auto selfIfaceTyCan = selfDecl->getInterfaceType();
-  SILType selfTy = SGF.getLoweredType(selfTyCan);
+  auto selfIfaceTy = selfDecl->getInterfaceType();
+  SILType selfTy = SGF.getLoweredType(selfDecl->getType());
 
   // Emit the indirect return argument, if any.
   SILValue resultSlot;
@@ -105,8 +117,8 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
                                  SourceLoc(),
                                  AC.getIdentifier("$return_value"),
                                  ctor);
-    VD->setInterfaceType(selfIfaceTyCan);
-    resultSlot = SGF.F.begin()->createFunctionArgument(selfTy, VD);
+    VD->setInterfaceType(selfIfaceTy);
+    resultSlot = SGF.F.begin()->createFunctionArgument(selfTy.getAddressType(), VD);
   }
 
   // Emit the elementwise arguments.
@@ -130,9 +142,9 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
     auto elti = elements.begin(), eltEnd = elements.end();
     for (VarDecl *field : decl->getStoredProperties()) {
       auto fieldTy = selfTy.getFieldType(field, SGF.SGM.M);
-      auto &fieldTL = SGF.getTypeLowering(fieldTy);
-      SILValue slot = SGF.B.createStructElementAddr(Loc, resultSlot, field,
-                                                    fieldTL.getLoweredType().getAddressType());
+      SILValue slot =
+        SGF.B.createStructElementAddr(Loc, resultSlot, field,
+                                      fieldTy.getAddressType());
       InitializationPtr init(new KnownAddressInitialization(slot));
 
       // An initialized 'let' property has a single value specified by the
@@ -378,12 +390,10 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
 }
 
 void SILGenFunction::emitEnumConstructor(EnumElementDecl *element) {
-  CanType enumIfaceTy = element->getParentEnum()
-                      ->getDeclaredInterfaceType()
-                      ->getCanonicalType();
-  CanType enumTy = F.mapTypeIntoContext(enumIfaceTy)
-                      ->getCanonicalType();
-  auto &enumTI = getTypeLowering(enumTy);
+  Type enumIfaceTy = element->getParentEnum()->getDeclaredInterfaceType();
+  Type enumTy = F.mapTypeIntoContext(enumIfaceTy);
+  auto &enumTI = SGM.Types.getTypeLowering(enumTy,
+                                           ResilienceExpansion::Minimal);
 
   RegularLocation Loc(element);
   CleanupLocation CleanupLoc(element);

lib/SILGen/SILGenDecl.cpp

@@ -374,7 +374,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 
     auto boxType = SGF.SGM.Types
       .getContextBoxTypeForCapture(decl,
-                     SGF.getLoweredType(decl->getType()).getASTType(),
+                     SGF.SGM.Types.getLoweredRValueType(decl->getType()),
                      SGF.F.getGenericEnvironment(),
                      /*mutable*/ true);
 

lib/SILGen/SILGenProlog.cpp

@@ -96,7 +96,9 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
   }
 
   ManagedValue visitType(CanType t, bool isInOut) {
-    auto argType = SGF.getLoweredType(t);
+    // The calling convention always uses minimal resilience expansion.
+    auto argType =
+        SGF.SGM.Types.getLoweredType(t, ResilienceExpansion::Minimal);
     if (isInOut)
       argType = SILType::getPrimitiveAddressType(argType.getASTType());
 
@@ -123,6 +125,15 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
     if (isInOut)
       return mv;
 
+    // This can happen if the value is resilient in the calling convention
+    // but not resilient locally.
+    if (argType.isLoadable(SGF.SGM.M) && argType.isAddress()) {
+      if (mv.isPlusOne(SGF))
+        mv = SGF.B.createLoadTake(loc, mv);
+      else
+        mv = SGF.B.createLoadBorrow(loc, mv);
+    }
+
     // If the value is a (possibly optional) ObjC block passed into the entry
     // point of the function, then copy it so we can treat the value reliably
     // as a heap object. Escape analysis can eliminate this copy if it's
@@ -142,7 +153,7 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
   ManagedValue visitTupleType(CanTupleType t) {
     SmallVector<ManagedValue, 4> elements;
 
-    auto &tl = SGF.getTypeLowering(t);
+    auto &tl = SGF.SGM.Types.getTypeLowering(t, ResilienceExpansion::Minimal);
     bool canBeGuaranteed = tl.isLoadable();
 
     // Collect the exploded elements.
@@ -305,7 +316,8 @@ static void makeArgument(Type ty, ParamDecl *decl,
     for (auto fieldType : tupleTy->getElementTypes())
       makeArgument(fieldType, decl, args, SGF);
   } else {
-    auto loweredTy = SGF.getLoweredType(ty);
+    auto loweredTy = SGF.SGM.Types.getLoweredType(ty,
+                                                  ResilienceExpansion::Minimal);
     if (decl->isInOut())
       loweredTy = SILType::getPrimitiveAddressType(loweredTy.getASTType());
     auto arg = SGF.F.begin()->createFunctionArgument(loweredTy, decl);
@@ -348,7 +360,8 @@ static void emitCaptureArguments(SILGenFunction &SGF,
 
   case CaptureKind::Constant: {
     auto type = getVarTypeInCaptureContext();
-    auto &lowering = SGF.getTypeLowering(type);
+    auto &lowering = SGF.SGM.Types.getTypeLowering(type,
+                                                   ResilienceExpansion::Minimal);
     // Constant decls are captured by value.
     SILType ty = lowering.getLoweredType();
     SILValue val = SGF.F.begin()->createFunctionArgument(ty, VD);
@@ -387,7 +400,7 @@ static void emitCaptureArguments(SILGenFunction &SGF,
     // the captured value.
     auto type = getVarTypeInCaptureContext();
     auto boxTy = SGF.SGM.Types.getContextBoxTypeForCapture(VD,
-                               SGF.getLoweredType(type).getASTType(),
+                               SGF.SGM.Types.getLoweredRValueType(type),
                                SGF.F.getGenericEnvironment(), /*mutable*/ true);
     SILValue box = SGF.F.begin()->createFunctionArgument(
         SILType::getPrimitiveObjectType(boxTy), VD);
@@ -460,8 +473,10 @@ static void emitIndirectResultParameters(SILGenFunction &SGF, Type resultType,
 
   // If the return type is address-only, emit the indirect return argument.
 
-  const TypeLowering &resultTI =
-      SGF.getTypeLowering(DC->mapTypeIntoContext(resultType));
+  // The calling convention always uses minimal resilience expansion.
+  auto &resultTI =
+    SGF.SGM.Types.getTypeLowering(DC->mapTypeIntoContext(resultType),
+                                  ResilienceExpansion::Minimal);
   if (!SILModuleConventions::isReturnedIndirectlyInSIL(
           resultTI.getLoweredType(), SGF.SGM.M)) {
     return;