[AddressLowering] Handle tuple_pack_extract.

By analogy with tuple_extract, transform the new instruction to
tuple_pack_element_addr.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -974,6 +974,9 @@ static Operand *getProjectedDefOperand(SILValue value) {
   case ValueKind::OpenExistentialBoxValueInst:
     assert(value->getOwnershipKind() == OwnershipKind::Guaranteed);
     return &cast<SingleValueInstruction>(value)->getAllOperands()[0];
+  case ValueKind::TuplePackExtractInst:
+    assert(value->getOwnershipKind() == OwnershipKind::Guaranteed);
+    return &cast<SingleValueInstruction>(value)->getAllOperands()[1];
   }
 }
 
@@ -1703,6 +1706,8 @@ class AddressMaterialization {
 
   SILValue materializeTupleExtract(SILInstruction *extractInst,
                                    SILValue elementValue, unsigned fieldIdx);
+  SILValue materializeTuplePackExtract(SILInstruction *extractInst,
+                                       SILValue elementValue, SILValue index);
 
   SILValue materializeProjectionIntoUse(Operand *operand, bool intoPhiOperand);
   SILValue materializeProjectionIntoUseImpl(Operand *operand,
@@ -1859,6 +1864,11 @@ SILValue AddressMaterialization::materializeDefProjection(SILValue origValue) {
     return materializeTupleExtract(extractInst, origValue,
                                    extractInst->getFieldIndex());
   }
+  case ValueKind::TuplePackExtractInst: {
+    auto *extractInst = cast<TuplePackExtractInst>(origValue);
+    return materializeTuplePackExtract(extractInst, origValue,
+                                       extractInst->getIndex());
+  }
   case ValueKind::SILPhiArgument: {
     // Handle this in the caller. unchecked_take_enum_data_addr is
     // destructive. It cannot be materialized on demand.
@@ -1888,6 +1898,14 @@ SILValue AddressMaterialization::materializeTupleExtract(
       elementValue->getType().getAddressType());
 }
 
+SILValue AddressMaterialization::materializeTuplePackExtract(
+    SILInstruction *extractInst, SILValue elementValue, SILValue fieldIdx) {
+  SILValue srcAddr = pass.getMaterializedAddress(extractInst->getOperand(1));
+  return projectionBuilder.createTuplePackElementAddr(
+      pass.genLoc(), fieldIdx, srcAddr,
+      elementValue->getType().getAddressType());
+}
+
 SILValue
 AddressMaterialization::materializeProjectionIntoUse(Operand *operand,
                                                      bool intoPhiOperand) {
@@ -3528,6 +3546,9 @@ class UseRewriter : SILInstructionVisitor<UseRewriter> {
   // Extract from an opaque tuple.
   void visitTupleExtractInst(TupleExtractInst *extractInst);
 
+  // Extract from an opaque pack tuple.
+  void visitTuplePackExtractInst(TuplePackExtractInst *extractInst);
+
   void
   visitUncheckedBitwiseCastInst(UncheckedBitwiseCastInst *uncheckedCastInst) {
     SILValue srcVal = uncheckedCastInst->getOperand();
@@ -3819,6 +3840,10 @@ void UseRewriter::visitTupleExtractInst(TupleExtractInst *extractInst) {
   emitExtract(extractInst);
 }
 
+void UseRewriter::visitTuplePackExtractInst(TuplePackExtractInst *extractInst) {
+  emitExtract(extractInst);
+}
+
 // Rewrite switch_enum to switch_enum_addr. All associated block arguments are
 // removed.
 void UseRewriter::visitSwitchEnumInst(SwitchEnumInst * switchEnum) {

test/SILOptimizer/address_lowering.sil

@@ -2688,6 +2688,26 @@ entry:
   return %retval : $()
 }
 
+// CHECK-LABEL: sil [ossa] @test_tuple_pack_extract : {{.*}} {
+// CHECK:       bb0([[TUPLE_PACK_ADDR:%[^,]+]] :
+// CHECK:         [[INDEX:%[^,]+]] = dynamic_pack_index
+// CHECK:         open_pack_element [[INDEX]] of <each U_1> at <Pack{repeat each T}>, shape $each U_1, uuid [[UUID:".*"]]
+// CHECK:         [[BORROW:%[^,]+]] = function_ref @borrowT
+// CHECK:         [[ELEMENT_ADDR:%[^,]+]] = tuple_pack_element_addr [[INDEX]] of [[TUPLE_PACK_ADDR]] : {{.*}} as $*@pack_element([[UUID]]) each U_1
+// CHECK:         apply [[BORROW]]<@pack_element([[UUID]]) each U_1>([[ELEMENT_ADDR]])
+// CHECK-LABEL: } // end sil function 'test_tuple_pack_extract'
+sil [ossa] @test_tuple_pack_extract : $@convention(thin) <each T> (@in_guaranteed (repeat each T)) -> () {
+entry(%tuple : @guaranteed $(repeat each T)):
+  %zero = integer_literal $Builtin.Word, 0
+  %index = dynamic_pack_index %zero of $Pack{repeat each T}
+  %opened = open_pack_element %index of <each U_1> at <Pack{repeat each T}>, shape $U_1, uuid "00000000-0000-0000-0000-000000000002"
+  %elt = tuple_pack_extract %index of %tuple : $(repeat each T) as $@pack_element("00000000-0000-0000-0000-000000000002") U_1
+  %borrow = function_ref @borrowT : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  apply %borrow<@pack_element("00000000-0000-0000-0000-000000000002") U_1>(%elt) : $@convention(thin) <T> (@in_guaranteed T) -> ()
+  %retval = tuple ()
+  return %retval : $()
+}
+
 // CHECK-LABEL: sil hidden [ossa] @test_unchecked_bitwise_cast :
 // CHECK: bb0(%0 : $*U, %1 : $*T, %2 : $@thick U.Type):
 // CHECK:   [[STK:%.*]] = alloc_stack $T