[sil] Templatize base class of FieldIndexCacheBase.

Previously FieldIndexCacheBase only had a parent class of
SingleValueInstruction. I need to be able to in certain cases shim in a
SingleValueInstruction subclass as a parent class instead. In my case it is to
imbue ownership forwarding on StructExtractInst.

This commit itself doesn't make that change and instead just always templatizes
using SingleValueInstruction.

Author: gottesmm

include/swift/Basic/InlineBitfield.h

@@ -81,6 +81,32 @@ namespace swift {
   LLVM_PACKED_END \
   static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
+/// Define a full bitfield for type 'T' that uses all of the remaining bits in
+/// the inline bitfield. We allow for 'T' to have a single generic parameter.
+///
+/// For optimal code gen, place naturally sized fields at the end, with the
+/// largest naturally sized field at the very end. For example:
+///
+/// SWIFT_INLINE_BITFIELD_FULL(Foo, Bar, 1+8+16,
+///   flag : 1,
+///   : NumPadBits, // pad the center, not the end
+///   x : 8,
+///   y : 16
+/// );
+///
+/// NOTE: All instances of Foo will access via the same bitfield entry even if
+/// they differ in the templated value!
+#define SWIFT_INLINE_BITFIELD_FULL_TEMPLATE(T, U, C, ...)                      \
+  LLVM_PACKED_START                                                            \
+  class T##Bitfield {                                                          \
+    template <typename TTy>                                                    \
+    friend class T;                                                            \
+    enum { NumPadBits = 64 - (Num##U##Bits + (C)) };                           \
+    uint64_t : Num##U##Bits, __VA_ARGS__;                                      \
+  } T;                                                                         \
+  LLVM_PACKED_END                                                              \
+  static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
+
 /// Define an empty bitfield for type 'T'.
 #define SWIFT_INLINE_BITFIELD_EMPTY(T, U) \
   enum { Num##T##Bits = Num##U##Bits }

include/swift/SIL/SILInstruction.h

@@ -5973,19 +5973,22 @@ VarDecl *getIndexedField(NominalTypeDecl *decl, unsigned index);
 /// because it would allow constant time lookup of either the VarDecl or the
 /// index from a single pointer without referring back to a projection
 /// instruction.
-class FieldIndexCacheBase : public SingleValueInstruction {
+template <typename ParentTy>
+class FieldIndexCacheBase : public ParentTy {
   enum : unsigned { InvalidFieldIndex = ~unsigned(0) };
 
   VarDecl *field;
 
 public:
+  template <typename... ArgTys>
   FieldIndexCacheBase(SILInstructionKind kind, SILDebugLocation loc,
-                      SILType type, VarDecl *field)
-      : SingleValueInstruction(kind, loc, type), field(field) {
+                      SILType type, VarDecl *field, ArgTys &&... extraArgs)
+      : ParentTy(kind, loc, type, std::forward<ArgTys>(extraArgs)...),
+        field(field) {
     SILInstruction::Bits.FieldIndexCacheBase.FieldIndex = InvalidFieldIndex;
     // This needs to be a concrete class to hold bitfield information. However,
     // it should only be extended by UnaryInstructions.
-    assert(getNumOperands() == 1);
+    assert(ParentTy::getNumOperands() == 1);
   }
 
   VarDecl *getField() const { return field; }
@@ -5999,7 +6002,8 @@ class FieldIndexCacheBase : public SingleValueInstruction {
   }
 
   NominalTypeDecl *getParentDecl() const {
-    auto s = getOperand(0)->getType().getNominalOrBoundGenericNominal();
+    auto s =
+        ParentTy::getOperand(0)->getType().getNominalOrBoundGenericNominal();
     assert(s);
     return s;
   }
@@ -6012,13 +6016,17 @@ class FieldIndexCacheBase : public SingleValueInstruction {
   }
 
 private:
-  unsigned cacheFieldIndex();
+  unsigned cacheFieldIndex() {
+    unsigned index = swift::getFieldIndex(getParentDecl(), getField());
+    SILInstruction::Bits.FieldIndexCacheBase.FieldIndex = index;
+    return index;
+  }
 };
 
 /// Extract a physical, fragile field out of a value of struct type.
 class StructExtractInst
     : public UnaryInstructionBase<SILInstructionKind::StructExtractInst,
-                                  FieldIndexCacheBase> {
+                                  FieldIndexCacheBase<SingleValueInstruction>> {
   friend SILBuilder;
 
   StructExtractInst(SILDebugLocation DebugLoc, SILValue Operand, VarDecl *Field,
@@ -6043,7 +6051,7 @@ class StructExtractInst
 /// Derive the address of a physical field from the address of a struct.
 class StructElementAddrInst
     : public UnaryInstructionBase<SILInstructionKind::StructElementAddrInst,
-                                  FieldIndexCacheBase> {
+                                  FieldIndexCacheBase<SingleValueInstruction>> {
   friend SILBuilder;
 
   StructElementAddrInst(SILDebugLocation DebugLoc, SILValue Operand,
@@ -6060,7 +6068,7 @@ class StructElementAddrInst
 /// type instance.
 class RefElementAddrInst
     : public UnaryInstructionBase<SILInstructionKind::RefElementAddrInst,
-                                  FieldIndexCacheBase> {
+                                  FieldIndexCacheBase<SingleValueInstruction>> {
   friend SILBuilder;
 
   RefElementAddrInst(SILDebugLocation DebugLoc, SILValue Operand,

include/swift/SIL/SILNode.h

@@ -317,9 +317,11 @@ class alignas(8) SILNode {
     KeepUnique : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(FieldIndexCacheBase, SingleValueInstruction, 32,
-                             : NumPadBits,
-                             FieldIndex : 32);
+  SWIFT_INLINE_BITFIELD_FULL_TEMPLATE(FieldIndexCacheBase,
+                                      SingleValueInstruction, 32,
+    : NumPadBits,
+    FieldIndex : 32
+  );
 
   SWIFT_INLINE_BITFIELD_EMPTY(MethodInst, SingleValueInstruction);
   // Ensure that WitnessMethodInst bitfield does not overflow.