Merge pull request swiftlang#63589 from rjmccall/pack_length

rjmccall · web-flow · commit 10e487b4cf1f · 2023-02-12T02:40:23.000-05:00
Add a pack_length SIL instruction for measuring the length of a pack
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -1946,6 +1946,13 @@ class SILBuilder {
         getSILDebugLocation(Loc), Existential));
   }
 
+  PackLengthInst *
+  createPackLength(SILLocation loc, CanPackType packType) {
+    return insert(PackLengthInst::create(getFunction(),
+                              getSILDebugLocation(loc),
+                              packType));
+  }
+
   DynamicPackIndexInst *
   createDynamicPackIndex(SILLocation loc, SILValue indexValue,
                          CanPackType indexedPackType) {
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -2495,6 +2495,17 @@ void SILCloner<ImplClass>::visitDeinitExistentialValueInst(
                 getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitPackLengthInst(PackLengthInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+
+  auto loc = getOpLocation(Inst->getLoc());
+  auto newPackType = cast<PackType>(getOpASTType(Inst->getPackType()));
+
+  recordClonedInstruction(
+      Inst, getBuilder().createPackLength(loc, newPackType));
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitDynamicPackIndexInst(
     DynamicPackIndexInst *Inst) {
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -7451,6 +7451,36 @@ class DeinitExistentialValueInst
       : UnaryInstructionBase(DebugLoc, Existential) {}
 };
 
+/// Compute the length of a pack (as a Builtin.Word).
+class PackLengthInst final
+    : public NullaryInstructionWithTypeDependentOperandsBase<
+                  SILInstructionKind::PackLengthInst,
+                  PackLengthInst,
+                  SingleValueInstruction> {
+  friend TrailingObjects;
+  friend SILBuilder;
+
+  CanPackType ThePackType;
+
+  PackLengthInst(SILDebugLocation loc,
+                 ArrayRef<SILValue> typeDependentOperands,
+                 SILType resultType,
+                 CanPackType packType)
+    : NullaryInstructionWithTypeDependentOperandsBase(loc,
+                                                      typeDependentOperands,
+                                                      resultType),
+      ThePackType(packType) {}
+
+  static PackLengthInst *create(SILFunction &parent,
+                                SILDebugLocation loc,
+                                CanPackType packType);
+public:
+  /// Return the measured pack type.
+  CanPackType getPackType() const {
+    return ThePackType;
+  }
+};
+
 /// An abstract class for instructions which producing variadic
 /// pack indices.
 ///
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
@@ -606,6 +606,18 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   // Variadic generics
   SINGLE_VALUE_INST(OpenPackElementInst, open_pack_element,
                     SingleValueInstruction, None, DoesNotRelease)
+  SINGLE_VALUE_INST(PackLengthInst, pack_length,
+                    SingleValueInstruction, None, DoesNotRelease)
+
+  // Variadic pack indexing
+  ABSTRACT_SINGLE_VALUE_INST(AnyPackIndexInst, SingleValueInstruction)
+    SINGLE_VALUE_INST(DynamicPackIndexInst, dynamic_pack_index,
+                      AnyPackIndexInst, None, DoesNotRelease)
+    SINGLE_VALUE_INST(PackPackIndexInst, pack_pack_index,
+                      AnyPackIndexInst, None, DoesNotRelease)
+    SINGLE_VALUE_INST(ScalarPackIndexInst, scalar_pack_index,
+                      AnyPackIndexInst, None, DoesNotRelease)
+    SINGLE_VALUE_INST_RANGE(AnyPackIndexInst, DynamicPackIndexInst, ScalarPackIndexInst)
 
   // Blocks
   SINGLE_VALUE_INST(ProjectBlockStorageInst, project_block_storage,
@@ -649,16 +661,6 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(KeyPathInst, keypath,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 
-  // Variadic pack indexing
-  ABSTRACT_SINGLE_VALUE_INST(AnyPackIndexInst, SingleValueInstruction)
-    SINGLE_VALUE_INST(DynamicPackIndexInst, dynamic_pack_index,
-                      AnyPackIndexInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(PackPackIndexInst, pack_pack_index,
-                      AnyPackIndexInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(ScalarPackIndexInst, scalar_pack_index,
-                      AnyPackIndexInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST_RANGE(AnyPackIndexInst, DynamicPackIndexInst, ScalarPackIndexInst)
-
   // BindMemory and RebindMemory have no physical side effect. Semantically they
   // write to their affected memory region because any reads or writes accessing
   // that memory must be dependent on the bind operation.
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -1276,6 +1276,7 @@ class IRGenSILFunction :
   void visitProjectExistentialBoxInst(ProjectExistentialBoxInst *i);
   void visitDeallocExistentialBoxInst(DeallocExistentialBoxInst *i);
   
+  void visitPackLengthInst(PackLengthInst *i);
   void visitOpenPackElementInst(OpenPackElementInst *i);
   void visitDynamicPackIndexInst(DynamicPackIndexInst *i);
   void visitPackPackIndexInst(PackPackIndexInst *i);
@@ -6869,6 +6870,11 @@ void IRGenSILFunction::visitOpenExistentialValueInst(
   llvm_unreachable("unsupported instruction during IRGen");
 }
 
+void IRGenSILFunction::visitPackLengthInst(PackLengthInst *i) {
+  auto length = emitPackShapeExpression(i->getPackType());
+  setLoweredSingletonExplosion(i, length);
+}
+
 void IRGenSILFunction::visitDynamicPackIndexInst(DynamicPackIndexInst *i) {
   // At the IRGen level, this is just a type change.
   auto index = getLoweredSingletonExplosion(i->getOperand());
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -99,6 +99,7 @@ SHOULD_NEVER_VISIT_INST(AllocExistentialBox)
 SHOULD_NEVER_VISIT_INST(AllocGlobal)
 SHOULD_NEVER_VISIT_INST(AllocStack)
 SHOULD_NEVER_VISIT_INST(AllocPack)
+SHOULD_NEVER_VISIT_INST(PackLength)
 SHOULD_NEVER_VISIT_INST(DifferentiabilityWitnessFunction)
 SHOULD_NEVER_VISIT_INST(FloatLiteral)
 SHOULD_NEVER_VISIT_INST(FunctionRef)
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -2267,6 +2267,28 @@ OpenExistentialValueInst::OpenExistentialValueInst(
     : UnaryInstructionBase(debugLoc, operand, selfTy, forwardingOwnershipKind) {
 }
 
+PackLengthInst *PackLengthInst::create(SILFunction &F,
+                                       SILDebugLocation loc,
+                                       CanPackType packType) {
+  auto resultType = SILType::getBuiltinWordType(F.getASTContext());
+
+  // Always reduce the pack shape.
+  packType = packType->getReducedShape();
+
+  // Under current limitations, that should reliably eliminate
+  // any local archetypes from the pack, but there's no real need to
+  // assume that in the SIL representation.
+  SmallVector<SILValue, 8> typeDependentOperands;
+  collectTypeDependentOperands(typeDependentOperands, F, packType);
+
+  size_t size =
+    totalSizeToAlloc<swift::Operand>(typeDependentOperands.size());
+  void *buffer =
+    F.getModule().allocateInst(size, alignof(PackLengthInst));
+  return ::new (buffer)
+      PackLengthInst(loc, typeDependentOperands, resultType, packType);
+}
+
 DynamicPackIndexInst *DynamicPackIndexInst::create(SILFunction &F,
                                                    SILDebugLocation loc,
                                                    SILValue indexOperand,
@@ -2276,7 +2298,7 @@ DynamicPackIndexInst *DynamicPackIndexInst::create(SILFunction &F,
   SmallVector<SILValue, 8> typeDependentOperands;
   collectTypeDependentOperands(typeDependentOperands, F, packType);
 
-  unsigned size =
+  size_t size =
     totalSizeToAlloc<swift::Operand>(1 + typeDependentOperands.size());
   void *buffer =
     F.getModule().allocateInst(size, alignof(DynamicPackIndexInst));
@@ -2299,7 +2321,7 @@ PackPackIndexInst *PackPackIndexInst::create(SILFunction &F,
   SmallVector<SILValue, 8> typeDependentOperands;
   collectTypeDependentOperands(typeDependentOperands, F, packType);
 
-  unsigned size =
+  size_t size =
     totalSizeToAlloc<swift::Operand>(1 + typeDependentOperands.size());
   void *buffer =
     F.getModule().allocateInst(size, alignof(PackPackIndexInst));
@@ -2322,7 +2344,7 @@ ScalarPackIndexInst *ScalarPackIndexInst::create(SILFunction &F,
   SmallVector<SILValue, 8> typeDependentOperands;
   collectTypeDependentOperands(typeDependentOperands, F, packType);
 
-  unsigned size =
+  size_t size =
     totalSizeToAlloc<swift::Operand>(typeDependentOperands.size());
   void *buffer =
     F.getModule().allocateInst(size, alignof(ScalarPackIndexInst));
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -2274,6 +2274,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   void visitDeallocExistentialBoxInst(DeallocExistentialBoxInst *DEI) {
     *this << getIDAndType(DEI->getOperand()) << ", $" << DEI->getConcreteType();
   }
+  void visitPackLengthInst(PackLengthInst *PLI) {
+    *this << "$" << PLI->getPackType();
+  }
   void visitDynamicPackIndexInst(DynamicPackIndexInst *DPII) {
     *this << Ctx.getID(DPII->getOperand()) << " of $"
           << DPII->getIndexedPackType();
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -94,6 +94,7 @@ CONSTANT_OWNERSHIP_INST(Owned, ObjCMetatypeToObject)
 CONSTANT_OWNERSHIP_INST(None, AddressToPointer)
 CONSTANT_OWNERSHIP_INST(None, AllocStack)
 CONSTANT_OWNERSHIP_INST(None, AllocPack)
+CONSTANT_OWNERSHIP_INST(None, PackLength)
 CONSTANT_OWNERSHIP_INST(None, BeginAccess)
 CONSTANT_OWNERSHIP_INST(None, BindMemory)
 CONSTANT_OWNERSHIP_INST(None, RebindMemory)
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -3284,6 +3284,14 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         B.createOpenExistentialValue(InstLoc, Val, Ty, forwardingOwnership);
     break;
   }
+  case SILInstructionKind::PackLengthInst: {
+    CanPackType packType;
+    if (P.parseToken(tok::sil_dollar, diag::expected_tok_in_sil_instr, "$") ||
+        parseASTPackType(packType))
+      return true;
+    ResultVal = B.createPackLength(InstLoc, packType);
+    break;
+  }
   case SILInstructionKind::DynamicPackIndexInst: {
     CanPackType packType;
     if (parseValueRef(Val, SILType::getBuiltinWordType(P.Context), InstLoc, B) ||
diff --git a/lib/SIL/Utils/InstructionUtils.cpp b/lib/SIL/Utils/InstructionUtils.cpp
@@ -492,6 +492,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
   case SILInstructionKind::ScalarPackIndexInst:
   case SILInstructionKind::PackElementGetInst:
   case SILInstructionKind::PackElementSetInst:
+  case SILInstructionKind::PackLengthInst:
   case SILInstructionKind::DebugStepInst:
     return RuntimeEffect::NoEffect;
 
diff --git a/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp b/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp
@@ -354,6 +354,12 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
     // Handle by operand and result check.
     break;
 
+  case SILInstructionKind::PackLengthInst:
+    // We reduce the pack shape, so it would very odd if this pack had
+    // opaque archetypes in it, but there's no harm in doing it right.
+    return opaqueArchetypeWouldChange(context,
+              cast<PackLengthInst>(&inst)->getPackType());
+
   case SILInstructionKind::DynamicPackIndexInst:
   case SILInstructionKind::PackPackIndexInst:
   case SILInstructionKind::ScalarPackIndexInst:
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -886,6 +886,10 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::TuplePackElementAddrInst:
     return InlineCost::Expensive;
 
+  // pack_length is just a few adds, which is close enough to free.
+  case SILInstructionKind::PackLengthInst:
+    return InlineCost::Free;
+
   // dynamic_pack_index is free.  The other pack-indexing instructions
   // are just adds of values that should be trivially dynamically
   // available; that's cheap enough to still consider free under the
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1329,6 +1329,12 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
         Loc, getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn));
     break;
   }
+  case SILInstructionKind::PackLengthInst: {
+    assert(RecordKind == SIL_ONE_TYPE && "Layout should be OneType.");
+    ResultInst = Builder.createPackLength(
+        Loc, cast<PackType>(MF->getType(TyID)->getCanonicalType()));
+    break;
+  }
   case SILInstructionKind::MetatypeInst:
     assert(RecordKind == SIL_ONE_TYPE && "Layout should be OneType.");
     ResultInst = Builder.createMetatype(
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1089,6 +1089,11 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     writeOneTypeLayout(API->getKind(), 0, API->getPackType());
     break;
   }
+  case SILInstructionKind::PackLengthInst: {
+    const PackLengthInst *PLI = cast<PackLengthInst>(&SI);
+    writeOneTypeLayout(PLI->getKind(), 0, PLI->getPackType());
+    break;
+  }
   case SILInstructionKind::ProjectBoxInst: {
     auto PBI = cast<ProjectBoxInst>(&SI);
     
diff --git a/test/IRGen/variadic_generics.sil b/test/IRGen/variadic_generics.sil
@@ -166,3 +166,21 @@ bb0(%tuple : $*(String, T, U, Int), %i : $Builtin.Word):
   %ret = tuple ()
   return %ret : $()
 }
+
+// CHECK-LABEL: define{{.*}} @test_pack_length_1
+// CHECK:         ret [[INT]] %0
+sil @test_pack_length_1 : $<T...> () -> Builtin.Word {
+bb0:
+  %len = pack_length $Pack{repeat each T}
+  return %len : $Builtin.Word
+}
+
+// CHECK-LABEL: define{{.*}} @test_pack_length_2
+// CHECK:         [[T0:%.*]] = add [[INT]] %0, %0
+// CHECK:         [[T1:%.*]] = add [[INT]] [[T0]], 3
+// CHECK:         ret [[INT]] [[T1]]
+sil @test_pack_length_2 : $<T...> () -> Builtin.Word {
+bb0:
+  %len = pack_length $Pack{repeat each T, repeat each T, Int, Float, String}
+  return %len : $Builtin.Word
+}
diff --git a/test/SIL/Parser/variadic_generics.sil b/test/SIL/Parser/variadic_generics.sil
@@ -88,3 +88,12 @@ bb0(%tuple : $*(String, repeat each T, Int), %i : $Builtin.Word):
   %ret = tuple ()
   return %ret : $()
 }
+
+// CHECK-LABEBL: sil @test7
+// CHECK:   [[LEN:%.*]] = pack_length $Pack{(), (), ()}
+// CHECK:   return [[LEN]] : $Builtin.Word
+sil @test7 : $() -> Builtin.Word {
+bb0:
+  %0 = pack_length $Pack{Int, Float, String}
+  return %0 : $Builtin.Word
+}
