Implement Value generics

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -24,6 +24,7 @@ swift_compiler_sources(Optimizer
   SimplifyInitEnumDataAddr.swift
   SimplifyKeyPath.swift
   SimplifyLoad.swift
+  SimplifyMisc.swift
   SimplifyPartialApply.swift
   SimplifyPointerToAddress.swift
   SimplifyRefCasts.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyMisc.swift

@@ -0,0 +1,32 @@
+//===--- SimplifyMisc.swift -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension TypeValueInst: OnoneSimplifyable, SILCombineSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    // If our parameter is not known statically, then bail.
+    guard paramType.isInteger() else {
+      return
+    }
+
+    // Note: Right now, value generics only support 'Int'. If we ever expand the
+    // scope of types supported, then this should change.
+    let fieldType = type.getNominalFields(in: parentFunction)![0]
+
+    let builder = Builder(before: self, context)
+    let intLiteral = builder.createIntegerLiteral(value, type: fieldType)
+    let structInst = builder.createStruct(type: type, elements: [intLiteral])
+    uses.replaceAll(with: structInst, context)
+    context.erase(instruction: self)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -108,6 +108,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
   registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
   registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
+  registerForSILCombine(TypeValueInst.self, { run(TypeValueInst.self, $0) })
 
   // Test passes
   registerPass(aliasInfoDumper, { aliasInfoDumper.run($0) })

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -718,6 +718,16 @@ class ExistentialMetatypeInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class ObjCProtocolInst : SingleValueInstruction {}
 
+final public class TypeValueInst: SingleValueInstruction, UnaryInstruction {
+  public var paramType: BridgedASTType {
+    bridged.TypeValueInst_getParamType()
+  }
+
+  public var value: Int {
+    bridged.TypeValueInst_getValue()
+  }
+}
+
 public class GlobalAccessInstruction : SingleValueInstruction {
   final public var global: GlobalVariable {
     bridged.GlobalAccessInst_getGlobal().globalVar

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -150,6 +150,7 @@ public func registerSILClasses() {
   register(MetatypeInst.self)
   register(ValueMetatypeInst.self)
   register(ExistentialMetatypeInst.self)
+  register(TypeValueInst.self)
   register(OpenPackElementInst.self)
   register(PackLengthInst.self)
   register(DynamicPackIndexInst.self)

docs/ABI/Mangling.rst

@@ -710,6 +710,10 @@ Types
   type ::= type 'Xm' METATYPE-REPR           // existential metatype with representation
   type ::= 'Xe'                              // error or unresolved type
 
+#if SWIFT_RUNTIME_VERSION >= 6.TBD
+  type ::= '$' 'n'? NATURAL_ZERO             // integer type
+#endif
+
   bound-generic-type ::= type 'y' (type* '_')* type* retroactive-conformance* 'G'   // one type-list per nesting level of type
   bound-generic-type ::= substitution
 
@@ -1008,11 +1012,18 @@ now codified into the ABI; the index 0 is therefore reserved.
 
 ::
 
-  generic-signature ::= requirement* generic-param-pack-marker* 'l'     // one generic parameter
-  generic-signature ::= requirement* generic-param-pack-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+  generic-signature ::= requirement* generic-param-marker 'l'     // one generic parameter
+  generic-signature ::= requirement* generic-param-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+
+  generic-param-marker ::= generic-param-pack-marker
+  generic-param-marker ::= generic-param-value-marker
 
   generic-param-pack-marker ::= 'Rv' GENERIC_PARAM-INDEX   // generic parameter pack marker
 
+#if SWIFT_RUNTIME_VERSION >= 6.TBD
+  generic-param-value-marker ::= type 'RV' GENERIC-PARAM-INDEX // generic parameter value marker
+#endif
+
   GENERIC-PARAM-COUNT ::= 'z'                // zero parameters
   GENERIC-PARAM-COUNT ::= INDEX              // N+1 parameters
 

docs/SIL.rst

@@ -7762,6 +7762,20 @@ element value operand is the projected element type of the pack element
 and must be structurally well-typed for the given index and pack type;
 see the structural type matching rules for pack indices.
 
+Value Generics
+~~~~~~~~~~~~~~~~~
+
+type_value
+```````````
+
+::
+
+  sil-instruction ::= 'type_value' sil-type 'for' sil-identifier
+
+Produce the dynamic value of the given value generic, which must be a formal
+value generic type. The value of the instruction has the type of whatever the
+underlying value generic's type is. For right now that is limited to ``Int``.
+
 Unchecked Conversions
 ~~~~~~~~~~~~~~~~~~~~~
 

include/swift/ABI/GenericContext.h

@@ -74,6 +74,10 @@ struct TargetGenericContextDescriptorHeader {
   ///   same order as the requirement descriptors which satisfy
   ///   hasKeyArgument().
   ///
+  ///   a sequence of values, in the same order as the parameter descriptors
+  ///   which satisify getKind() == GenericParamKind::Value and
+  ///   hasKeyArgument();
+  ///
   /// The elements above which are packs are precisely those appearing
   /// in the sequence of trailing GenericPackShapeDescriptors.
   uint16_t NumKeyArguments;
@@ -319,6 +323,18 @@ struct ConditionalInvertibleProtocolSet: InvertibleProtocolSet {
 template<typename Runtime>
 struct TargetConditionalInvertibleProtocolRequirement: TargetGenericRequirementDescriptor<Runtime> { };
 
+struct GenericValueHeader {
+  /// The total number of generic parameters in this signature where
+  /// getKind() == GenericParamKind::Value.
+  uint32_t NumValues;
+};
+
+/// The GenericValueHeader is followed by an array of these descriptors,
+/// whose length is given by the header's NumValues field.
+struct GenericValueDescriptor {
+  GenericValueType Type;
+};
+
 /// An array of generic parameter descriptors, all
 /// GenericParamDescriptor::implicit(), which is by far
 /// the most common case.  Some generic context storage can
@@ -356,20 +372,26 @@ class RuntimeGenericSignature {
   const TargetGenericRequirementDescriptor<Runtime> *Requirements;
   GenericPackShapeHeader PackShapeHeader;
   const GenericPackShapeDescriptor *PackShapeDescriptors;
+  GenericValueHeader ValueHeader;
+  const GenericValueDescriptor *ValueDescriptors;
 
 public:
   RuntimeGenericSignature()
-    : Header{0, 0, 0, GenericContextDescriptorFlags(false, false)},
+    : Header{0, 0, 0, GenericContextDescriptorFlags(false, false, false)},
       Params(nullptr), Requirements(nullptr),
-      PackShapeHeader{0, 0}, PackShapeDescriptors(nullptr) {}
+      PackShapeHeader{0, 0}, PackShapeDescriptors(nullptr), ValueHeader{0},
+      ValueDescriptors(nullptr) {}
 
   RuntimeGenericSignature(const TargetGenericContextDescriptorHeader<Runtime> &header,
                           const GenericParamDescriptor *params,
                           const TargetGenericRequirementDescriptor<Runtime> *requirements,
                           const GenericPackShapeHeader &packShapeHeader,
-                          const GenericPackShapeDescriptor *packShapeDescriptors)
+                          const GenericPackShapeDescriptor *packShapeDescriptors,
+                          const GenericValueHeader &valueHeader,
+                          const GenericValueDescriptor *valueDescriptors)
     : Header(header), Params(params), Requirements(requirements),
-      PackShapeHeader(packShapeHeader), PackShapeDescriptors(packShapeDescriptors) {}
+      PackShapeHeader(packShapeHeader), PackShapeDescriptors(packShapeDescriptors),
+      ValueHeader(valueHeader), ValueDescriptors(valueDescriptors) {}
 
   llvm::ArrayRef<GenericParamDescriptor> getParams() const {
     return llvm::ArrayRef(Params, Header.NumParams);
@@ -387,6 +409,14 @@ class RuntimeGenericSignature {
     return llvm::ArrayRef(PackShapeDescriptors, PackShapeHeader.NumPacks);
   }
 
+  const GenericValueHeader &getGenericValueHeader() const {
+    return ValueHeader;
+  }
+
+  llvm::ArrayRef<GenericValueDescriptor> getGenericValueDescriptors() const {
+    return llvm::ArrayRef(ValueDescriptors, ValueHeader.NumValues);
+  }
+
   size_t getArgumentLayoutSizeInWords() const {
     return Header.getArgumentLayoutSizeInWords();
   }
@@ -482,6 +512,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
       ConditionalInvertibleProtocolSet,
       ConditionalInvertibleProtocolsRequirementCount,
       TargetConditionalInvertibleProtocolRequirement<Runtime>,
+      GenericValueHeader,
+      GenericValueDescriptor,
       FollowingTrailingObjects...>
 {
 protected:
@@ -500,6 +532,8 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     ConditionalInvertibleProtocolSet,
     ConditionalInvertibleProtocolsRequirementCount,
     GenericConditionalInvertibleProtocolRequirement,
+    GenericValueHeader,
+    GenericValueDescriptor,
     FollowingTrailingObjects...>;
   friend TrailingObjects;
 
@@ -648,13 +682,33 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
             header.NumPacks};
   }
 
+  GenericValueHeader getGenericValueHeader() const {
+    if (!asSelf()->isGeneric())
+      return {0};
+    if (!getGenericContextHeader().Flags.hasValues())
+      return {0};
+    return *this->template getTrailingObjects<GenericValueHeader>();
+  }
+
+  llvm::ArrayRef<GenericValueDescriptor> getGenericValueDescriptors() const {
+    auto header = getGenericValueHeader();
+
+    if (header.NumValues == 0)
+      return {};
+
+    return {this->template getTrailingObjects<GenericValueDescriptor>(),
+            header.NumValues};
+  }
+
   RuntimeGenericSignature<Runtime> getGenericSignature() const {
     if (!asSelf()->isGeneric()) return RuntimeGenericSignature<Runtime>();
     return {getGenericContextHeader(),
             getGenericParams().data(),
             getGenericRequirements().data(),
             getGenericPackShapeHeader(),
-            getGenericPackShapeDescriptors().data()};
+            getGenericPackShapeDescriptors().data(),
+            getGenericValueHeader(),
+            getGenericValueDescriptors().data()};
   }
 
 protected:
@@ -713,6 +767,23 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
     return counts.empty() ? 0 : counts.back().count;
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericValueHeader>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    return getGenericContextHeader().Flags.hasValues() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(OverloadToken<GenericValueDescriptor>) const {
+    if (!asSelf()->isGeneric())
+      return 0;
+
+    if (!getGenericContextHeader().Flags.hasValues())
+      return 0;
+
+    return getGenericValueHeader().NumValues;
+  }
+
 #if defined(_MSC_VER) && _MSC_VER < 1920
 #undef OverloadToken
 #endif

include/swift/ABI/Metadata.h

@@ -2145,7 +2145,7 @@ struct TargetExtendedExistentialTypeShape
 
   RuntimeGenericSignature<Runtime> getRequirementSignature() const {
     return {ReqSigHeader, getReqSigParams(), getReqSigRequirements(),
-            {0, 0}, nullptr};
+            {0, 0}, nullptr, {0}, nullptr};
   }
 
   unsigned getNumReqSigParams() const {
@@ -2225,7 +2225,8 @@ struct TargetExtendedExistentialTypeShape
   RuntimeGenericSignature<Runtime> getGeneralizationSignature() const {
     if (!hasGeneralizationSignature()) return RuntimeGenericSignature<Runtime>();
     return {*getGenSigHeader(), getGenSigParams(), getGenSigRequirements(),
-            getGenSigPackShapeHeader(), getGenSigPackShapeDescriptors()};
+            getGenSigPackShapeHeader(), getGenSigPackShapeDescriptors(),
+            {0}, nullptr};
   }
 
   unsigned getNumGenSigParams() const {