[NFC] Introduce NullaryInstructionWithTypeDependentOperandsBase

rjmccall · rjmccall · commit 7825d177a931 · 2023-01-19T23:57:13.000-05:00
We have a similar helper class for the unary-but-for case, might
as well have one for the nullary-but-for case.
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -1823,6 +1823,49 @@ class InstructionBaseWithTrailingOperands
   }
 };
 
+/// A template base class for instructions that take no operands except
+/// for type-dependent operands. The operands are tail allocated after the
+/// instruction. Further trailing data can be allocated as well if
+/// TRAILING_TYPES are provided.
+template<SILInstructionKind Kind,
+         typename Derived,
+         typename Base,
+         typename... OtherTrailingTypes>
+class NullaryInstructionWithTypeDependentOperandsBase
+    : public InstructionBaseWithTrailingOperands<Kind, Derived, Base,
+                                                 OtherTrailingTypes...> {
+protected:
+  friend InstructionBaseWithTrailingOperands<Kind, Derived, Operand,
+                                             OtherTrailingTypes...>;
+
+  using TrailingObjects =
+      InstructionBaseWithTrailingOperands<Kind, Derived, Operand,
+                                          OtherTrailingTypes...>;
+
+  template <typename... Args>
+  NullaryInstructionWithTypeDependentOperandsBase(SILDebugLocation debugLoc,
+                                    ArrayRef<SILValue> typeDependentOperands,
+                                    Args &&...args)
+      : InstructionBaseWithTrailingOperands<Kind, Derived, Base,
+                                            OtherTrailingTypes...>(
+                                              typeDependentOperands,
+                                              debugLoc,
+                                              std::forward<Args>(args)...) {}
+
+public:
+  unsigned getNumTypeDependentOperands() const {
+    return this->getAllOperands().size();
+  }
+
+  ArrayRef<Operand> getTypeDependentOperands() const {
+    return this->getAllOperands();
+  }
+
+  MutableArrayRef<Operand> getTypeDependentOperands() {
+    return this->getAllOperands();
+  }
+};
+
 /// A template base class for instructions that take a single regular SILValue
 /// operand, a set of type dependent operands and has no result
 /// or a single value result. The operands are tail allocated after the
@@ -2351,7 +2394,7 @@ class AllocRefDynamicInst final
 /// is an address pointing to the contained element. The contained
 /// element is uninitialized.
 class AllocBoxInst final
-    : public InstructionBaseWithTrailingOperands<
+    : public NullaryInstructionWithTypeDependentOperandsBase<
                                            SILInstructionKind::AllocBoxInst,
                                            AllocBoxInst, AllocationInst, char>
 {
@@ -2392,14 +2435,6 @@ class AllocBoxInst final
   Optional<SILDebugVariable> getVarInfo() const {
     return VarInfo.get(getDecl(), getTrailingObjects<char>());
   };
-
-  ArrayRef<Operand> getTypeDependentOperands() const {
-    return getAllOperands();
-  }
-
-  MutableArrayRef<Operand> getTypeDependentOperands() {
-    return getAllOperands();
-  }
 };
 
 /// This represents the allocation of a heap box for an existential container.
@@ -2408,7 +2443,7 @@ class AllocBoxInst final
 /// is an address pointing to the contained element. The contained
 /// value is uninitialized.
 class AllocExistentialBoxInst final
-    : public InstructionBaseWithTrailingOperands<
+    : public NullaryInstructionWithTypeDependentOperandsBase<
                                    SILInstructionKind::AllocExistentialBoxInst,
                                    AllocExistentialBoxInst, AllocationInst> {
   friend SILBuilder;
@@ -2420,7 +2455,8 @@ class AllocExistentialBoxInst final
                           ArrayRef<ProtocolConformanceRef> Conformances,
                           ArrayRef<SILValue> TypeDependentOperands,
                           SILFunction *Parent)
-    : InstructionBaseWithTrailingOperands(TypeDependentOperands, DebugLoc,
+    : NullaryInstructionWithTypeDependentOperandsBase(DebugLoc,
+                                          TypeDependentOperands,
                                           ExistentialType.getObjectType()),
       ConcreteType(ConcreteType), Conformances(Conformances) {}
 
@@ -2437,14 +2473,6 @@ class AllocExistentialBoxInst final
   ArrayRef<ProtocolConformanceRef> getConformances() const {
     return Conformances;
   }
-
-  ArrayRef<Operand> getTypeDependentOperands() const {
-    return getAllOperands();
-  }
-
-  MutableArrayRef<Operand> getTypeDependentOperands() {
-    return getAllOperands();
-  }
 };
 
 /// GenericSpecializationInformation - provides information about a generic
@@ -6660,28 +6688,19 @@ class SelectValueInst final
 /// MetatypeInst - Represents the production of an instance of a given metatype
 /// named statically.
 class MetatypeInst final
-    : public InstructionBaseWithTrailingOperands<
+    : public NullaryInstructionWithTypeDependentOperandsBase<
                                          SILInstructionKind::MetatypeInst,
                                          MetatypeInst, SingleValueInstruction> {
   friend SILBuilder;
 
   /// Constructs a MetatypeInst
   MetatypeInst(SILDebugLocation DebugLoc, SILType Metatype,
                ArrayRef<SILValue> TypeDependentOperands)
-    : InstructionBaseWithTrailingOperands(TypeDependentOperands, DebugLoc,
-                                          Metatype) {}
+    : NullaryInstructionWithTypeDependentOperandsBase(DebugLoc,
+                                          TypeDependentOperands, Metatype) {}
 
   static MetatypeInst *create(SILDebugLocation DebugLoc, SILType Metatype,
                               SILFunction *F);
-
-public:
-  ArrayRef<Operand> getTypeDependentOperands() const {
-    return getAllOperands();
-  }
-
-  MutableArrayRef<Operand> getTypeDependentOperands() {
-    return getAllOperands();
-  }
 };
 
 /// Represents loading a dynamic metatype from a value.
@@ -7029,7 +7048,7 @@ class ObjCSuperMethodInst
 /// and a protocol method constant, extracts the implementation of that method
 /// for the type.
 class WitnessMethodInst final
-    : public InstructionBaseWithTrailingOperands<
+    : public NullaryInstructionWithTypeDependentOperandsBase<
                                           SILInstructionKind::WitnessMethodInst,
                                           WitnessMethodInst, MethodInst> {
   friend SILBuilder;
@@ -7040,8 +7059,8 @@ class WitnessMethodInst final
   WitnessMethodInst(SILDebugLocation DebugLoc, CanType LookupType,
                     ProtocolConformanceRef Conformance, SILDeclRef Member,
                     SILType Ty, ArrayRef<SILValue> TypeDependentOperands)
-      : InstructionBaseWithTrailingOperands(TypeDependentOperands,
-                                            DebugLoc, Ty, Member),
+      : NullaryInstructionWithTypeDependentOperandsBase(DebugLoc,
+                                          TypeDependentOperands, Ty, Member),
         LookupType(LookupType), Conformance(Conformance) {}
 
   /// Create a witness method call of a protocol requirement, passing in a lookup
@@ -7068,14 +7087,6 @@ class WitnessMethodInst final
   }
 
   ProtocolConformanceRef getConformance() const { return Conformance; }
-
-  ArrayRef<Operand> getTypeDependentOperands() const {
-    return getAllOperands();
-  }
-
-  MutableArrayRef<Operand> getTypeDependentOperands() {
-    return getAllOperands();
-  }
 };
 
 /// Access allowed to the opened value by the open_existential_addr instruction.
@@ -7420,7 +7431,7 @@ class DeinitExistentialValueInst
 /// the pack type parameters, and the requirements on the pack type
 /// parameters.
 class OpenPackElementInst final
-    : public InstructionBaseWithTrailingOperands<
+    : public UnaryInstructionWithTypeDependentOperandsBase<
                                         SILInstructionKind::OpenPackElementInst,
                                         OpenPackElementInst,
                                         SingleValueInstruction> {
@@ -7460,7 +7471,8 @@ class OpenPackElementInst final
   GenericEnvironment *Env;
 
   OpenPackElementInst(SILDebugLocation debugLoc,
-                      ArrayRef<SILValue> allOperands,
+                      SILValue packIndexOperand,
+                      ArrayRef<SILValue> typeDependentOperands,
                       SILType type,
                       GenericEnvironment *env);
 
@@ -7481,14 +7493,6 @@ class OpenPackElementInst final
   SILValue getIndexOperand() const {
     return getAllOperands()[0].get();
   }
-
-  ArrayRef<Operand> getTypeDependentOperands() const {
-    return getAllOperands().slice(1);
-  }
-
-  MutableArrayRef<Operand> getTypeDependentOperands() {
-    return getAllOperands().slice(1);
-  }
 };
 
 /// Projects the capture storage address from a @block_storage address.
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -360,8 +360,8 @@ AllocBoxInst::AllocBoxInst(SILDebugLocation Loc, CanSILBoxType BoxType,
                            SILFunction &F, Optional<SILDebugVariable> Var,
                            bool hasDynamicLifetime,
                            bool reflection)
-    : InstructionBaseWithTrailingOperands(
-          TypeDependentOperands, Loc, SILType::getPrimitiveObjectType(BoxType)),
+    : NullaryInstructionWithTypeDependentOperandsBase(
+          Loc, TypeDependentOperands, SILType::getPrimitiveObjectType(BoxType)),
       VarInfo(Var, getTrailingObjects<char>()),
       HasDynamicLifetime(hasDynamicLifetime),
       Reflection(reflection) {}
@@ -2253,9 +2253,11 @@ OpenExistentialValueInst::OpenExistentialValueInst(
 }
 
 OpenPackElementInst::OpenPackElementInst(
-    SILDebugLocation debugLoc, ArrayRef<SILValue> allOperands,
+    SILDebugLocation debugLoc, SILValue packIndexOperand,
+    ArrayRef<SILValue> typeDependentOperands,
     SILType type, GenericEnvironment *env)
-    : InstructionBaseWithTrailingOperands(allOperands, debugLoc, type),
+    : UnaryInstructionWithTypeDependentOperandsBase(debugLoc, packIndexOperand,
+                                                    typeDependentOperands, type),
       Env(env) {
 }
 
@@ -2264,24 +2266,24 @@ OpenPackElementInst *OpenPackElementInst::create(
     GenericEnvironment *env) {
   assert(indexOperand->getType().is<BuiltinPackIndexType>());
 
-  SmallVector<SILValue, 8> allOperands;
-  allOperands.push_back(indexOperand);
+  SmallVector<SILValue, 8> typeDependentOperands;
 
   // open_pack_element references the pack substitutions and
   // the types used in the shape class.
-  TypeDependentOperandCollector typeDependentOperands;
+  TypeDependentOperandCollector collector;
   env->forEachPackElementBinding([&](ElementArchetypeType *elementType,
                                      PackType *packSubstitution) {
-    typeDependentOperands.collect(packSubstitution->getCanonicalType());
+    collector.collect(packSubstitution->getCanonicalType());
   });
-  typeDependentOperands.collect(env->getOpenedElementShapeClass());
-  typeDependentOperands.addTo(allOperands, F);
+  collector.collect(env->getOpenedElementShapeClass());
+  collector.addTo(typeDependentOperands, F);
 
   SILType type = SILType::getSILTokenType(F.getASTContext());
 
-  auto size = totalSizeToAlloc<swift::Operand>(allOperands.size());
+  auto size = totalSizeToAlloc<swift::Operand>(1 + typeDependentOperands.size());
   auto buffer = F.getModule().allocateInst(size, alignof(OpenPackElementInst));
-  return ::new (buffer) OpenPackElementInst(debugLoc, allOperands, type, env);
+  return ::new (buffer) OpenPackElementInst(debugLoc, indexOperand,
+                                            typeDependentOperands, type, env);
 }
 
 BeginCOWMutationInst::BeginCOWMutationInst(SILDebugLocation loc,
