SIL: add the alloc_vector and vector instructions

* `alloc_vector`: allocates an uninitialized vector of elements on the stack or in a statically initialized global
* `vector`: creates an initialized vector in a statically initialized global

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -92,6 +92,11 @@ public struct Builder {
     return notifyNew(dr.getAs(AllocStackInst.self))
   }
 
+  public func createAllocVector(capacity: Value, elementType: Type) -> AllocVectorInst {
+    let dr = bridged.createAllocVector(capacity.bridged, elementType.bridged)
+    return notifyNew(dr.getAs(AllocVectorInst.self))
+  }
+
   @discardableResult
   public func createDeallocStack(_ operand: Value) -> DeallocStackInst {
     let dr = bridged.createDeallocStack(operand.bridged)
@@ -292,6 +297,14 @@ public struct Builder {
     return notifyNew(objectInst.getAs(ObjectInst.self))
   }
 
+  @discardableResult
+  public func createVector(type: Type, arguments: [Value]) -> VectorInst {
+    let vectorInst = arguments.withBridgedValues { valuesRef in
+      return bridged.createVector(valuesRef)
+    }
+    return notifyNew(vectorInst.getAs(VectorInst.self))
+  }
+
   public func createGlobalAddr(global: GlobalVariable) -> GlobalAddrInst {
     return notifyNew(bridged.createGlobalAddr(global.bridged).getAs(GlobalAddrInst.self))
   }

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -142,6 +142,8 @@ extension Instruction {
          is IntegerLiteralInst,
          is FloatLiteralInst,
          is ObjectInst,
+         is VectorInst,
+         is AllocVectorInst,
          is ValueToBridgeObjectInst,
          is ConvertFunctionInst,
          is ThinToThickFunctionInst,

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -974,6 +974,9 @@ final public class ObjectInst : SingleValueInstruction {
   }
 }
 
+final public class VectorInst : SingleValueInstruction {
+}
+
 final public class TuplePackExtractInst: SingleValueInstruction, ForwardingInstruction {
   public var indexOperand: Operand { operands[0] }
   public var tupleOperand: Operand { operands[1] }
@@ -1001,6 +1004,10 @@ final public class AllocStackInst : SingleValueInstruction, Allocation, DebugVar
   }
 }
 
+final public class AllocVectorInst : SingleValueInstruction, Allocation, UnaryInstruction {
+  public var capacity: Value { operand.value }
+}
+
 public class AllocRefInstBase : SingleValueInstruction, Allocation {
   final public var isObjC: Bool { bridged.AllocRefInstBase_isObjc() }
 

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -87,6 +87,7 @@ public func registerSILClasses() {
   register(UncheckedTrivialBitCastInst.self)
   register(MarkUnresolvedNonCopyableValueInst.self)
   register(ObjectInst.self)
+  register(VectorInst.self)
   register(TuplePackExtractInst.self)
   register(DifferentiableFunctionInst.self)
   register(LinearFunctionInst.self)
@@ -161,6 +162,7 @@ public func registerSILClasses() {
   register(IsUniqueInst.self)
   register(IsEscapingClosureInst.self)
   register(AllocStackInst.self)
+  register(AllocVectorInst.self)
   register(AllocRefInst.self)
   register(AllocRefDynamicInst.self)
   register(AllocBoxInst.self)

docs/SIL.rst

@@ -3790,6 +3790,28 @@ type, use ``alloc_box``.
 
 ``T`` must not be a pack type.  To allocate a pack, use ``alloc_pack``.
 
+alloc_vector
+````````````
+::
+
+  sil-instruction ::= 'alloc_vector' sil-type, sil-operand
+
+  %1 = alloc_vector $T, %0 : $Builtin.Word
+  // %1 has type $*T
+
+Allocates uninitialized memory that is sufficiently aligned on the stack to
+contain a vector of values of type ``T``. The result of the instruction is
+the address of the allocated memory.
+The number of vector elements is specified by the operand, which must be a
+builtin integer value.
+
+``alloc_vector`` either allocates memory on the stack or - if contained in a
+global variable static initializer list - in the data section.
+
+``alloc_vector`` is a stack allocation instruction, unless it's contained in a
+global initializer list.  See the section above on stack discipline.  The
+corresponding stack deallocation instruction is ``dealloc_stack``.
+
 alloc_pack
 ``````````
 
@@ -6689,6 +6711,20 @@ object
 Constructs a statically initialized object. This instruction can only appear
 as final instruction in a global variable static initializer list.
 
+vector
+``````
+
+::
+
+  sil-instruction ::= 'vector' '(' (sil-operand (',' sil-operand)*)? ')'
+
+  vector (%a : $T, %b : $T, ...)
+  // $T must be a non-generic or bound generic reference type
+  // All operands must have the same type
+
+Constructs a statically initialized vector of elements. This instruction can only appear
+as final instruction in a global variable static initializer list.
+
 ref_element_addr
 ````````````````
 ::

include/swift/SIL/SILBridging.h

@@ -900,6 +900,8 @@ struct BridgedBuilder{
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createIntegerLiteral(BridgedType type, SwiftInt value) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createAllocStack(BridgedType type,
                                           bool hasDynamicLifetime, bool isLexical, bool wasMoved) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createAllocVector(BridgedValue capacity,
+                                                                          BridgedType type) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createDeallocStack(BridgedValue operand) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createDeallocStackRef(BridgedValue operand) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createAddressToPointer(BridgedValue address,
@@ -950,6 +952,7 @@ struct BridgedBuilder{
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createUnreachable() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createObject(BridgedType type, BridgedValueArray arguments,
                                                                      SwiftInt numBaseElements) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createVector(BridgedValueArray arguments) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalAddr(BridgedGlobalVar global) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalValue(BridgedGlobalVar global,
                                                                           bool isBare) const;

include/swift/SIL/SILBridgingImpl.h

@@ -1262,6 +1262,10 @@ BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,
                                        isLexical, wasMoved)};
 }
 
+BridgedInstruction BridgedBuilder::createAllocVector(BridgedValue capacity, BridgedType type) const {
+  return {unbridged().createAllocVector(regularLoc(), capacity.getSILValue(), type.unbridged())};
+}
+
 BridgedInstruction BridgedBuilder::createDeallocStack(BridgedValue operand) const {
   return {unbridged().createDeallocStack(regularLoc(), operand.getSILValue())};
 }
@@ -1423,6 +1427,11 @@ BridgedInstruction BridgedBuilder::createObject(BridgedType type,
       arguments.getValues(argValues), numBaseElements)};
 }
 
+BridgedInstruction BridgedBuilder::createVector(BridgedValueArray arguments) const {
+  llvm::SmallVector<swift::SILValue, 16> argValues;
+  return {unbridged().createVector(swift::ArtificialUnreachableLocation(), arguments.getValues(argValues))};
+}
+
 BridgedInstruction BridgedBuilder::createGlobalAddr(BridgedGlobalVar global) const {
   return {unbridged().createGlobalAddr(regularLoc(), global.getGlobal())};
 }

include/swift/SIL/SILBuilder.h

@@ -418,6 +418,16 @@ class SILBuilder {
         wasMoved));
   }
 
+  AllocVectorInst *
+  createAllocVector(SILLocation loc, SILValue capacity, SILType elementType) {
+    if (isInsertingIntoGlobal()) {
+      return insert(AllocVectorInst::createInInitializer(
+          getSILDebugLocation(loc, true), capacity, elementType, getModule()));
+    }
+    return insert(AllocVectorInst::create(
+        getSILDebugLocation(loc, true), capacity, elementType, getFunction()));
+  }
+
   AllocPackInst *createAllocPack(SILLocation loc, SILType packType) {
     return insert(AllocPackInst::create(getSILDebugLocation(loc), packType,
                                         getFunction()));
@@ -1614,6 +1624,11 @@ class SILBuilder {
                                      forwardingOwnershipKind));
   }
 
+  VectorInst *createVector(SILLocation Loc, ArrayRef<SILValue> Elements) {
+    return insert(VectorInst::create(getSILDebugLocation(Loc), Elements,
+                                     getModule()));
+  }
+
   StructInst *createStruct(SILLocation Loc, SILType Ty,
                            ArrayRef<SILValue> Elements) {
     return createStruct(Loc, Ty, Elements,

include/swift/SIL/SILCloner.h

@@ -889,6 +889,17 @@ SILCloner<ImplClass>::visitAllocStackInst(AllocStackInst *Inst) {
   recordClonedInstruction(Inst, NewInst);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitAllocVectorInst(
+    AllocVectorInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(Inst, getBuilder().createAllocVector(
+                                    getOpLocation(Inst->getLoc()),
+                                    getOpValue(Inst->getCapacity()),
+                                    getOpType(Inst->getElementType())));
+}
+
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitAllocPackMetadataInst(
     AllocPackMetadataInst *Inst) {
@@ -2154,6 +2165,16 @@ SILCloner<ImplClass>::visitObjectInst(ObjectInst *Inst) {
                                     : ValueOwnershipKind(OwnershipKind::None)));
 }
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitVectorInst(VectorInst *Inst) {
+  auto Elements = getOpValueArray<8>(Inst->getElements());
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst,
+      getBuilder().createVector(getOpLocation(Inst->getLoc()), Elements));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitStructInst(StructInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -2115,6 +2115,35 @@ class AllocStackInst final
   DeallocStackInst *getSingleDeallocStack() const;
 };
 
+/// AllocVectorInst - Like AllocStackInst, but allocates a vector of elements.
+class AllocVectorInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+           SILInstructionKind::AllocVectorInst, AllocVectorInst, AllocationInst> {
+  friend SILBuilder;
+
+  AllocVectorInst(SILDebugLocation loc, SILValue capacity, SILType resultType,
+                  ArrayRef<SILValue> typeDependentOperands)
+    : UnaryInstructionWithTypeDependentOperandsBase(loc, capacity,
+                                                    typeDependentOperands,
+                                                    resultType) {
+  }
+
+  static AllocVectorInst *create(SILDebugLocation Loc, SILValue capacity,
+                                 SILType elementType, SILFunction &F);
+
+  static AllocVectorInst *createInInitializer(SILDebugLocation Loc,
+                        SILValue capacity, SILType elementType, SILModule &M);
+
+public:
+  /// getElementType - Get the type of the allocated memory (as opposed to the
+  /// type of the instruction itself, which will be an address type).
+  SILType getElementType() const {
+    return getType().getObjectType();
+  }
+
+  SILValue getCapacity() const { return getOperand(); }
+};
+
 /// AllocPackInst - This represents the allocation of a value pack
 /// in stack memory.  The memory is provided uninitialized.
 class AllocPackInst final
@@ -6294,6 +6323,28 @@ class ObjectInst final : public InstructionBaseWithTrailingOperands<
   }
 };
 
+/// VectorInst - Represents a vector value type.
+///
+/// This instruction can only appear at the end of a global variable's
+/// static initializer list.
+class VectorInst final : public InstructionBaseWithTrailingOperands<
+                                SILInstructionKind::VectorInst, VectorInst,
+                                SingleValueInstruction> {
+  friend SILBuilder;
+
+  VectorInst(SILDebugLocation DebugLoc, ArrayRef<SILValue> Elements)
+      : InstructionBaseWithTrailingOperands(Elements, DebugLoc,
+                                            Elements[0]->getType()) {}
+
+  static VectorInst *create(SILDebugLocation DebugLoc,
+                            ArrayRef<SILValue> Elements,
+                            SILModule &M);
+public:
+  OperandValueArrayRef getElements() const {
+    return OperandValueArrayRef(getAllOperands());
+  }
+};
+
 /// TupleInst - Represents a constructed loadable tuple.
 class TupleInst final : public InstructionBaseWithTrailingOperands<
                             SILInstructionKind::TupleInst, TupleInst,