IRGen: Peephole (copy_addr to [initialization] (init_existential_addr)) as well.

We can simultaneously allocate and initialize an opaque existential container's fixed-size buffer the same way, which benefits conversions from generic types to protocol types.

Swift SVN r29371

Author: jckarter

lib/IRGen/GenProto.cpp

@@ -4995,7 +4995,8 @@ void irgen::emitClassExistentialContainer(IRGenFunction &IGF,
 }
 
 /// Emit an existential container initialization operation for a concrete type.
-/// Returns the address of the uninitialized buffer for the concrete value.
+/// Returns the address of the uninitialized fixed-size buffer for the concrete
+/// value.
 Address irgen::emitOpaqueExistentialContainerInit(IRGenFunction &IGF,
                                   Address dest,
                                   SILType destType,
@@ -5005,26 +5006,13 @@ Address irgen::emitOpaqueExistentialContainerInit(IRGenFunction &IGF,
   assert(!destType.isClassExistentialType() &&
          "initializing a class existential container as opaque");
   auto &destTI = IGF.getTypeInfo(destType).as<OpaqueExistentialTypeInfo>();
-  auto &srcTI = IGF.getTypeInfo(loweredSrcType);
   OpaqueExistentialLayout destLayout = destTI.getLayout();
   assert(destTI.getStoredProtocols().size() == conformances.size());
 
   // First, write out the metadata.
   llvm::Value *metadata = IGF.emitTypeMetadataRef(formalSrcType);
   IGF.Builder.CreateStore(metadata, destLayout.projectMetadataRef(IGF, dest));
 
-  // Compute basic layout information about the type.  If we have a
-  // concrete type, we need to know how it packs into a fixed-size
-  // buffer.  If we don't, we need a value witness table.
-  FixedPacking packing;
-  bool needValueWitnessToAllocate;
-  if (!isa<FixedTypeInfo>(srcTI)) {
-    packing = (FixedPacking) -1;
-    needValueWitnessToAllocate = true;
-  } else {
-    packing = srcTI.getFixedPacking(IGF.IGM);
-    needValueWitnessToAllocate = false;
-  }
 
   // Next, write the protocol witness tables.
   forEachProtocolWitnessTable(IGF, formalSrcType, destType.getSwiftRValueType(),
@@ -5037,26 +5025,7 @@ Address irgen::emitOpaqueExistentialContainerInit(IRGenFunction &IGF,
   // Finally, evaluate into the buffer.
 
   // Project down to the destination fixed-size buffer.
-  Address buffer = destLayout.projectExistentialBuffer(IGF, dest);
-
-  // If the type is provably empty, we're done.
-  if (srcTI.isKnownEmpty()) {
-    assert(packing == FixedPacking::OffsetZero);
-    return buffer;
-  }
-
-  // Otherwise, allocate if necessary.
-
-  if (needValueWitnessToAllocate) {
-    // If we're using a witness-table to do this, we need to emit a
-    // value-witness call to allocate the fixed-size buffer.
-    return Address(emitAllocateBufferCall(IGF, loweredSrcType, buffer),
-                   Alignment(1));
-  } else {
-    // Otherwise, allocate using what we know statically about the type.
-    return emitAllocateBuffer(IGF, loweredSrcType,
-                              srcTI, packing, buffer);
-  }
+  return destLayout.projectExistentialBuffer(IGF, dest);
 }
 
 /// Emit an existential metatype container from a metatype value

lib/IRGen/IRGenSIL.cpp

@@ -49,6 +49,7 @@
 #include "GenHeap.h"
 #include "GenMeta.h"
 #include "GenObjC.h"
+#include "GenOpaque.h"
 #include "GenPoly.h"
 #include "GenProto.h"
 #include "GenStruct.h"
@@ -3219,6 +3220,7 @@ static bool tryDeferFixedSizeBufferInitialization(IRGenSILFunction &IGF,
                                                   const TypeInfo &ti,
                                                   SILValue containerValue,
                                                   SILValue addressValue,
+                                                  Address fixedSizeBuffer,
                                                   const llvm::Twine &name) {
   // There's no point in doing this for fixed-sized types, since we'll allocate
   // an appropriately-sized buffer for them statically.
@@ -3254,7 +3256,8 @@ static bool tryDeferFixedSizeBufferInitialization(IRGenSILFunction &IGF,
 
     // We can defer to this initialization. Allocate the fixed-size buffer
     // now, but don't allocate the value inside it.
-    auto fixedSizeBuffer = IGF.createFixedSizeBufferAlloca(name);
+    if (!fixedSizeBuffer.getAddress())
+      fixedSizeBuffer = IGF.createFixedSizeBufferAlloca(name);
     if (containerValue)
       IGF.setLoweredAddress(containerValue, fixedSizeBuffer);
     IGF.setLoweredUnallocatedAddressInBuffer(addressValue, fixedSizeBuffer);
@@ -3307,6 +3310,7 @@ void IRGenSILFunction::visitAllocStackInst(swift::AllocStackInst *i) {
   if (tryDeferFixedSizeBufferInitialization(*this, i, type,
                                             i->getContainerResult(),
                                             i->getAddressResult(),
+                                            Address(),
                                             dbgname))
     return;
 
@@ -4076,7 +4080,52 @@ void IRGenSILFunction::visitInitExistentialAddrInst(swift::InitExistentialAddrIn
                                                 i->getFormalConcreteType(),
                                                 i->getLoweredConcreteType(),
                                                 i->getConformances());
-  setLoweredAddress(SILValue(i, 0), buffer);
+
+  auto &srcTI = getTypeInfo(i->getLoweredConcreteType());
+
+  // See if we can defer initialization of the buffer to a copy_addr into it.
+  if (tryDeferFixedSizeBufferInitialization(*this, i, srcTI, SILValue(), i,
+                                            buffer, ""))
+    return;
+  
+  // Compute basic layout information about the type.  If we have a
+  // concrete type, we need to know how it packs into a fixed-size
+  // buffer.  If we don't, we need a value witness table.
+  
+  
+  FixedPacking packing;
+  bool needValueWitnessToAllocate;
+  if (!isa<FixedTypeInfo>(srcTI)) {
+    packing = (FixedPacking) -1;
+    needValueWitnessToAllocate = true;
+  } else {
+    packing = srcTI.getFixedPacking(IGM);
+    needValueWitnessToAllocate = false;
+  }
+
+  // Project down to the destination fixed-size buffer.
+  Address address = [&]{
+    // If the type is provably empty, we're done.
+    if (srcTI.isKnownEmpty()) {
+      assert(packing == FixedPacking::OffsetZero);
+      return buffer;
+    }
+    
+      // Otherwise, allocate if necessary.
+
+    if (needValueWitnessToAllocate) {
+      // If we're using a witness-table to do this, we need to emit a
+      // value-witness call to allocate the fixed-size buffer.
+      return Address(emitAllocateBufferCall(*this, i->getLoweredConcreteType(),
+                                            buffer),
+                     Alignment(1));
+    } else {
+      // Otherwise, allocate using what we know statically about the type.
+      return emitAllocateBuffer(*this, i->getLoweredConcreteType(), buffer);
+    }
+  }();
+  
+  setLoweredAddress(SILValue(i, 0), address);
 }
 
 void IRGenSILFunction::visitInitExistentialMetatypeInst(
@@ -4297,7 +4346,7 @@ void IRGenSILFunction::visitCopyAddrInst(swift::CopyAddrInst *i) {
       Address addr = addrTI.initializeBufferWithTake(*this, dest, src, addrTy);
       setAllocatedAddressForBuffer(i->getDest(), addr);
     } else
-      addrTI.initializeWithTake(*this, dest, src, addrTy);      
+      addrTI.initializeWithTake(*this, dest, src, addrTy);
     break;
   default:
     llvm_unreachable("unexpected take/initialize attribute combination?!");

test/IRGen/fixed_size_buffer_peepholes.sil

@@ -19,6 +19,18 @@ entry(%x : $*T):
   return undef : $()
 }
 
+protocol P {}
+
+// CHECK-LABEL: define void @join_init_existential_copy_addr(%P27fixed_size_buffer_peepholes1P_* noalias nocapture sret, %swift.opaque* noalias nocapture, %swift.type* %T, i8** %T.P)
+// CHECK:         [[BUFFER:%.*]] = getelementptr inbounds %P27fixed_size_buffer_peepholes1P_, %P27fixed_size_buffer_peepholes1P_* %0, i32 0, i32 0
+// CHECK:         call %swift.opaque* %initializeBufferWithTake([[BUFFER_TYPE]]* [[BUFFER]], %swift.opaque* %1
+sil @join_init_existential_copy_addr : $@convention(thin) <T: P> (@out P, @in T) -> () {
+entry(%p : $*P, %x: $*T):
+  %y = init_existential_addr %p : $*P, $T
+  copy_addr [take] %x to [initialization] %y : $*T
+  return undef : $()
+}
+
 // CHECK-LABEL: define void @dont_join_alloc_stack_copy_addr_if_intervening_use
 sil @dont_join_alloc_stack_copy_addr_if_intervening_use : $@convention(thin) <T> (@in T) -> () {
 entry(%x : $*T):
@@ -67,3 +79,5 @@ next:
   dealloc_stack %a#0 : $*@local_storage T
   return undef : $()
 }
+
+