Merge pull request #18501 from jckarter/block-silgen-crash-41056468

SILGen: Handle reabstraction in attempted +0 argument peephole.

Author: jckarter

cmake/modules/DarwinSDKs.cmake

@@ -1,5 +1,15 @@
+option(SWIFT_ENABLE_IOS32
+       "Build 32-bit variants of iOS"
+       TRUE)
+
+if(SWIFT_ENABLE_IOS32)
 set(SUPPORTED_IOS_ARCHS "armv7;armv7s;arm64")
 set(SUPPORTED_IOS_SIMULATOR_ARCHS "i386;x86_64")
+else()
+set(SUPPORTED_IOS_ARCHS "arm64")
+set(SUPPORTED_IOS_SIMULATOR_ARCHS "x86_64")
+endif()
+
 set(SUPPORTED_TVOS_ARCHS "arm64")
 set(SUPPORTED_TVOS_SIMULATOR_ARCHS "x86_64")
 set(SUPPORTED_WATCHOS_ARCHS "armv7k")

lib/SILGen/SILGenExpr.cpp

@@ -1118,15 +1118,20 @@ RValue SILGenFunction::emitRValueForStorageLoad(
   }
 
   // If the base is a reference type, just handle this as loading the lvalue.
+  ManagedValue result;
   if (baseFormalType->hasReferenceSemantics()) {
     LValue LV = emitPropertyLValue(loc, base, baseFormalType, field,
                                    LValueOptions(), AccessKind::Read,
                                    AccessSemantics::DirectToStorage);
-    return emitLoadOfLValue(loc, std::move(LV), C, isBaseGuaranteed);
-  }
-
-  ManagedValue result;
-  if (!base.getType().isAddress()) {
+    auto loaded = emitLoadOfLValue(loc, std::move(LV), C, isBaseGuaranteed);
+    // If we don't have to reabstract, the load is sufficient.
+    if (!hasAbstractionChange)
+      return loaded;
+    
+    // Otherwise, bring the component up to +1 so we can reabstract it.
+    result = std::move(loaded).getAsSingleValue(*this, loc)
+                              .copyUnmanaged(*this, loc);
+  } else if (!base.getType().isAddress()) {
     // For non-address-only structs, we emit a struct_extract sequence.
     result = B.createStructExtract(loc, base, field);
 
@@ -2361,7 +2366,7 @@ class NominalTypeMemberRefRValueEmitter {
     // If the field is not a let, bail. We need to use the lvalue logic.
     if (!Field->isLet())
       return None;
-
+    
     // If we are emitting a delegating init super and we have begun the
     // super.init call, since self has been exclusively borrowed, we need to be
     // conservative and use the lvalue machinery. This ensures that we properly

test/SILGen/guaranteed-let-peephole-reabstraction.swift

@@ -0,0 +1,22 @@
+// RUN: %target-swift-emit-silgen -enable-sil-ownership -verify %s 
+class BlockBox<T> {
+  let block: (T) -> Void = { _ in }
+
+  var computedBlock: (T) -> Void { return { _ in } }
+}
+
+struct BlockStruct<T> {
+  let block: (T) -> Void = { _ in }
+  var computedBlock: (T) -> Void { return { _ in } }
+}
+
+func escapingCompletion(completion: @escaping (String) -> Void) {}
+
+func foo(box: BlockBox<String>) {
+  escapingCompletion(completion: box.block)
+  escapingCompletion(completion: box.computedBlock)
+}
+func foo(struc: BlockStruct<String>) {
+  escapingCompletion(completion: struc.block)
+  escapingCompletion(completion: struc.computedBlock)
+}