Merge pull request #67966 from nate-chandler/opaque-values/20230816/1/indirect-pack-tuple-handling

[AddressLowering] Handle indexing into variadic tuples.

Author: nate-chandler

docs/SIL.rst

@@ -6403,6 +6403,23 @@ tuple_extract
 
 Extracts an element from a loadable tuple value.
 
+
+tuple_pack_extract
+``````````````````
+::
+
+  sil-instruction ::= 'tuple_pack_extract' sil-value 'of' sil-operand 'as' sil-type
+
+  %value = tuple_pack_extract %index of %tuple : $(repeat each T) as $@pack_element("01234567-89AB-CDEF-0123-000000000000") U
+  // %index must be of $Builtin.PackIndex type
+  // %tuple must be of tuple type
+  // %addr will be the result type specified by the 'as' clause
+
+Extracts a value at a dynamic index from a tuple value.
+
+Only valid in opaque values mode.  Lowered by AddressLowering to
+tuple_pack_element_addr.  For more details, see that instruction.
+
 tuple_element_addr
 ``````````````````
 ::

include/swift/SIL/InstWrappers.h

@@ -304,6 +304,7 @@ class ForwardingOperation {
   bool canForwardGuaranteedCompatibleValuesOnly() {
     switch (forwardingInst->getKind()) {
     case SILInstructionKind::TupleExtractInst:
+    case SILInstructionKind::TuplePackExtractInst:
     case SILInstructionKind::StructExtractInst:
     case SILInstructionKind::DifferentiableFunctionExtractInst:
     case SILInstructionKind::LinearFunctionExtractInst:

include/swift/SIL/SILBuilder.h

@@ -2150,6 +2150,16 @@ class SILBuilder {
                               packIndex, tupleAddr, elementType));
   }
 
+  TuplePackExtractInst *createTuplePackExtract(SILLocation loc,
+                                               SILValue packIndex,
+                                               SILValue tuple,
+                                               SILType elementType) {
+    assert(!getFunction().getModule().useLoweredAddresses());
+    return insert(TuplePackExtractInst::create(
+        getFunction(), getSILDebugLocation(loc), packIndex, tuple, elementType,
+        tuple->getOwnershipKind()));
+  }
+
   ProjectBlockStorageInst *createProjectBlockStorage(SILLocation Loc,
                                                      SILValue Storage) {
     auto CaptureTy = Storage->getType()

include/swift/SIL/SILCloner.h

@@ -2780,6 +2780,27 @@ void SILCloner<ImplClass>::visitTuplePackElementAddrInst(
                                                     newElementType));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitTuplePackExtractInst(
+    TuplePackExtractInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto loc = getOpLocation(Inst->getLoc());
+  auto newIndex = getOpValue(Inst->getIndex());
+  auto newTuple = getOpValue(Inst->getTuple());
+  auto newElementType = getOpType(Inst->getElementType());
+
+  // If the tuple-ness of the operand disappears due to substitution,
+  // replace this instruction with an unchecked_value_cast.
+  if (doesOpTupleDisappear(Inst->getTupleType())) {
+    recordClonedInstruction(Inst, getBuilder().createUncheckedValueCast(
+                                      loc, newTuple, newElementType));
+    return;
+  }
+
+  recordClonedInstruction(Inst, getBuilder().createTuplePackExtract(
+                                    loc, newIndex, newTuple, newElementType));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitCopyBlockInst(CopyBlockInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -7805,6 +7805,45 @@ class TuplePackElementAddrInst final
   }
 };
 
+/// Extracts a tuple element as appropriate for the given
+/// pack element index.  The pack index must index into a pack with
+/// the same shape as the tuple element type list.
+///
+/// Legal only in opaque values mode.  Transformed by AddressLowering to
+/// TuplePackElementAddrInst.
+class TuplePackExtractInst final
+    : public InstructionBaseWithTrailingOperands<
+          SILInstructionKind::TuplePackExtractInst, TuplePackExtractInst,
+          OwnershipForwardingSingleValueInstruction> {
+public:
+  enum { IndexOperand = 0, TupleOperand = 1 };
+
+private:
+  friend SILBuilder;
+
+  TuplePackExtractInst(SILDebugLocation debugLoc,
+                       ArrayRef<SILValue> allOperands, SILType elementType,
+                       ValueOwnershipKind forwardingOwnershipKind)
+      : InstructionBaseWithTrailingOperands(allOperands, debugLoc, elementType,
+                                            forwardingOwnershipKind) {}
+
+  static TuplePackExtractInst *
+  create(SILFunction &F, SILDebugLocation debugLoc, SILValue indexOperand,
+         SILValue tupleOperand, SILType elementType,
+         ValueOwnershipKind forwardingOwnershipKind);
+
+public:
+  SILValue getIndex() const { return getAllOperands()[IndexOperand].get(); }
+
+  SILValue getTuple() const { return getAllOperands()[TupleOperand].get(); }
+
+  CanTupleType getTupleType() const {
+    return getTuple()->getType().castTo<TupleType>();
+  }
+
+  SILType getElementType() const { return getType(); }
+};
+
 /// Projects the capture storage address from a @block_storage address.
 class ProjectBlockStorageInst
   : public UnaryInstructionBase<SILInstructionKind::ProjectBlockStorageInst,
@@ -10543,6 +10582,7 @@ OwnershipForwardingSingleValueInstruction::classof(SILInstructionKind kind) {
   case SILInstructionKind::CopyableToMoveOnlyWrapperValueInst:
   case SILInstructionKind::MarkUninitializedInst:
   case SILInstructionKind::TupleExtractInst:
+  case SILInstructionKind::TuplePackExtractInst:
   case SILInstructionKind::StructExtractInst:
   case SILInstructionKind::DifferentiableFunctionExtractInst:
   case SILInstructionKind::LinearFunctionExtractInst:

include/swift/SIL/SILNodes.def

@@ -588,6 +588,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                     SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(TuplePackElementAddrInst, tuple_pack_element_addr,
                     SingleValueInstruction, None, DoesNotRelease)
+  SINGLE_VALUE_INST(TuplePackExtractInst, tuple_pack_extract,
+                    SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(PackElementGetInst, pack_element_get,
                     SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(StructInst, struct,

lib/IRGen/IRGenSIL.cpp

@@ -1355,6 +1355,7 @@ class IRGenSILFunction :
   void visitPackElementGetInst(PackElementGetInst *i);
   void visitPackElementSetInst(PackElementSetInst *i);
   void visitTuplePackElementAddrInst(TuplePackElementAddrInst *i);
+  void visitTuplePackExtractInst(TuplePackExtractInst *i);
 
   void visitProjectBlockStorageInst(ProjectBlockStorageInst *i);
   void visitInitBlockStorageHeaderInst(InitBlockStorageHeaderInst *i);
@@ -7192,6 +7193,11 @@ void IRGenSILFunction::visitTuplePackElementAddrInst(
   setLoweredAddress(i, elementAddr);
 }
 
+void IRGenSILFunction::visitTuplePackExtractInst(TuplePackExtractInst *i) {
+  llvm::report_fatal_error(
+      "tuple_pack_extract not lowered by AddressLowering!?");
+}
+
 void IRGenSILFunction::visitProjectBlockStorageInst(ProjectBlockStorageInst *i){
   // TODO
   Address block = getLoweredAddress(i->getOperand());

lib/SIL/IR/OperandOwnership.cpp

@@ -312,6 +312,7 @@ OPERAND_OWNERSHIP(PointerEscape, ExtractExecutor)
 
 // Instructions that propagate a value within a borrow scope.
 OPERAND_OWNERSHIP(GuaranteedForwarding, TupleExtract)
+OPERAND_OWNERSHIP(GuaranteedForwarding, TuplePackExtract)
 OPERAND_OWNERSHIP(GuaranteedForwarding, StructExtract)
 OPERAND_OWNERSHIP(GuaranteedForwarding, DifferentiableFunctionExtract)
 OPERAND_OWNERSHIP(GuaranteedForwarding, LinearFunctionExtract)

lib/SIL/IR/SILInstructions.cpp

@@ -2423,6 +2423,26 @@ TuplePackElementAddrInst::create(SILFunction &F,
                                                  elementType);
 }
 
+TuplePackExtractInst *
+TuplePackExtractInst::create(SILFunction &F, SILDebugLocation debugLoc,
+                             SILValue indexOperand, SILValue tupleOperand,
+                             SILType elementType,
+                             ValueOwnershipKind forwardingOwnershipKind) {
+  assert(indexOperand->getType().is<BuiltinPackIndexType>());
+  assert(tupleOperand->getType().isObject() &&
+         tupleOperand->getType().is<TupleType>());
+
+  SmallVector<SILValue, 8> allOperands;
+  allOperands.push_back(indexOperand);
+  allOperands.push_back(tupleOperand);
+  collectTypeDependentOperands(allOperands, F, elementType);
+
+  auto size = totalSizeToAlloc<swift::Operand>(allOperands.size());
+  auto buffer = F.getModule().allocateInst(size, alignof(TuplePackExtractInst));
+  return ::new (buffer) TuplePackExtractInst(debugLoc, allOperands, elementType,
+                                             forwardingOwnershipKind);
+}
+
 BeginCOWMutationInst::BeginCOWMutationInst(SILDebugLocation loc,
                                SILValue operand,
                                ArrayRef<SILType> resultTypes,

lib/SIL/IR/SILPrinter.cpp

@@ -2431,6 +2431,10 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
           << getIDAndType(I->getTuple()) << " as "
           << I->getElementType();
   }
+  void visitTuplePackExtractInst(TuplePackExtractInst *I) {
+    *this << Ctx.getID(I->getIndex()) << " of " << getIDAndType(I->getTuple())
+          << " as " << I->getElementType();
+  }
   void visitProjectBlockStorageInst(ProjectBlockStorageInst *PBSI) {
     *this << getIDAndType(PBSI->getOperand());
   }

lib/SIL/IR/ValueOwnership.cpp

@@ -183,6 +183,7 @@ CONSTANT_OWNERSHIP_INST(None, TuplePackElementAddr)
   }
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, StructExtract)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, TupleExtract)
+CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, TuplePackExtract)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, DifferentiableFunctionExtract)
 CONSTANT_OR_NONE_OWNERSHIP_INST(Guaranteed, LinearFunctionExtract)
 // OpenExistentialValue opens the boxed value inside an existential

lib/SIL/Parser/ParseSIL.cpp

@@ -3591,6 +3591,17 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     ResultVal = B.createTuplePackElementAddr(InstLoc, index, tuple, elementType);
     break;
   }
+  case SILInstructionKind::TuplePackExtractInst: {
+    SILValue index, tuple;
+    SILType elementType;
+    if (parseValueRef(index, SILType::getPackIndexType(P.Context), InstLoc,
+                      B) ||
+        parseVerbatim("of") || parseTypedValueRef(tuple, B) ||
+        parseVerbatim("as") || parseSILType(elementType))
+      return true;
+    ResultVal = B.createTuplePackExtract(InstLoc, index, tuple, elementType);
+    break;
+  }
 
 #define UNARY_INSTRUCTION(ID)                                                  \
   case SILInstructionKind::ID##Inst:                                           \

lib/SIL/Utils/InstructionUtils.cpp

@@ -588,6 +588,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
     return RuntimeEffect::Allocating | RuntimeEffect::Releasing |
            RuntimeEffect::MetaData;
 
+  case SILInstructionKind::TuplePackExtractInst:
   case SILInstructionKind::TuplePackElementAddrInst:
     return RuntimeEffect::MetaData;
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -5961,6 +5961,32 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                           /*types are SIL types*/ true);
   }
 
+  void checkTuplePackExtractInst(TuplePackExtractInst *i) {
+    require(!F.getModule().useLoweredAddresses(),
+            "tuple_pack_extract is only valid in opaque values");
+    auto index = requireValueKind<AnyPackIndexInst>(
+        i->getIndex(),
+        "pack index operand must be one of the pack_index instructions");
+    if (!index)
+      return;
+
+    // Remove the extra tuple element type structure.
+    SmallVector<CanType, 8> tupleElements;
+    {
+      auto tupleType = requireObjectType(TupleType, i->getTuple()->getType(),
+                                         "tuple operand of tuple_pack_extract");
+      auto eltTypes = tupleType.getElementTypes();
+      tupleElements.append(eltTypes.begin(), eltTypes.end());
+    }
+
+    require(i->getElementType().isObject(),
+            "result of tuple_pack_extract must be an object");
+
+    verifyPackElementType(tupleElements, index,
+                          i->getElementType().getASTType(),
+                          /*types are SIL types*/ true);
+  }
+
   // This verifies that the entry block of a SIL function doesn't have
   // any predecessors and also verifies the entry point arguments.
   void verifyEntryBlock(SILBasicBlock *entry) {

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) {

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -241,6 +241,7 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
   case SILInstructionKind::ObjectInst:
   case SILInstructionKind::TupleInst:
   case SILInstructionKind::TupleExtractInst:
+  case SILInstructionKind::TuplePackExtractInst:
   case SILInstructionKind::TupleElementAddrInst:
   case SILInstructionKind::StructInst:
   case SILInstructionKind::StructExtractInst:

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -896,6 +896,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   // tuple_pack_element_addr is just a GEP, but getting the offset
   // can require accessing metadata, so conservatively treat it as
   // expensive.
+  case SILInstructionKind::TuplePackExtractInst:
   case SILInstructionKind::TuplePackElementAddrInst:
     return InlineCost::Expensive;
 

lib/Serialization/DeserializeSIL.cpp

@@ -1494,6 +1494,18 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
                                                     elementType);
     break;
   }
+  case SILInstructionKind::TuplePackExtractInst: {
+    assert(RecordKind == SIL_PACK_ELEMENT_GET);
+    auto elementType =
+        getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn);
+    auto tupleType =
+        getSILType(MF->getType(TyID2), (SILValueCategory)TyCategory2, Fn);
+    auto tuple = getLocalValue(ValID2, tupleType);
+    auto indexType = SILType::getPackIndexType(MF->getContext());
+    auto index = getLocalValue(ValID3, indexType);
+    ResultInst = Builder.createTuplePackExtract(Loc, index, tuple, elementType);
+    break;
+  }
 
 #define ONEOPERAND_ONETYPE_INST(ID)                                            \
   case SILInstructionKind::ID##Inst:                                           \

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 801; // removing builtin tuple conformances
+const uint16_t SWIFTMODULE_VERSION_MINOR = 802; // added tuple_pack_extract
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///