SIL: add the vector_base_addr instruction

It derives the address of the first element of a vector, i.e. a `Builtin.FixedArray`, from the address of the vector itself.
Addresses of other vector elements can then be derived with `index_addr`.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/Verifier.swift

@@ -148,6 +148,16 @@ extension LoadBorrowInst : VerifiableInstruction {
   }
 }
 
+extension VectorBaseAddrInst : VerifiableInstruction {
+  func verify(_ context: FunctionPassContext) {
+    require(vector.type.isBuiltinFixedArray,
+            "vector operand of vector_element_addr must be a Builtin.FixedArray")
+    require(type == vector.type.builtinFixedArrayElementType(in: parentFunction,
+                                                             maximallyAbstracted: true).addressType,
+            "result of vector_element_addr has wrong type")
+  }
+}
+
 // Used to check if any instruction is mutating the memory location within the liverange of a `load_borrow`.
 // Note that it is not checking if an instruction _may_ mutate the memory, but it's checking if any instruction
 // _definitely_ will mutate the memory.

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -487,6 +487,10 @@ public struct Builder {
     return notifyNew(vectorInst.getAs(VectorInst.self))
   }
 
+  public func createVectorBaseAddr(vector: Value) -> VectorBaseAddrInst {
+    return notifyNew(bridged.createVectorBaseAddr(vector.bridged).getAs(VectorBaseAddrInst.self))
+  }
+
   public func createGlobalAddr(global: GlobalVariable, dependencyToken: Value?) -> GlobalAddrInst {
     return notifyNew(bridged.createGlobalAddr(global.bridged, dependencyToken.bridged).getAs(GlobalAddrInst.self))
   }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1350,6 +1350,10 @@ final public class ObjectInst : SingleValueInstruction {
 final public class VectorInst : SingleValueInstruction {
 }
 
+final public class VectorBaseAddrInst : SingleValueInstruction, UnaryInstruction {
+  public var vector: Value { operand.value }
+}
+
 final public class DifferentiableFunctionInst: SingleValueInstruction {}
 
 final public class LinearFunctionInst: SingleValueInstruction {}

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -118,6 +118,7 @@ public func registerSILClasses() {
   register(MoveOnlyWrapperToCopyableAddrInst.self)
   register(ObjectInst.self)
   register(VectorInst.self)
+  register(VectorBaseAddrInst.self)
   register(TuplePackExtractInst.self)
   register(TuplePackElementAddrInst.self)
   register(PackElementGetInst.self)

docs/SIL/Instructions.md

@@ -3467,6 +3467,20 @@ Constructs a statically initialized vector of elements. This instruction
 can only appear as final instruction in a global variable static
 initializer list.
 
+### vector_base_addr
+
+```
+sil-instruction ::= 'vector_base_addr' sil-operand
+
+%1 = vector_base_addr %0 : $*Builtin.FixedArray<N, Element>
+// %0 must have type $*Builtin.FixedArray
+// %1 will be of the element type of the Builtin.FixedArray
+```
+
+Derives the address of the first element of a vector, i.e. a `Builtin.FixedArray`,
+from the address of the vector itself.
+Addresses of other vector elements can then be derived with `index_addr`.
+
 ### ref_element_addr
 
 ```

include/swift/SIL/AddressWalker.h

@@ -249,6 +249,7 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) {
         isa<BeginAccessInst>(user) || isa<TailAddrInst>(user) ||
         isa<IndexAddrInst>(user) || isa<StoreBorrowInst>(user) ||
         isa<UncheckedAddrCastInst>(user) ||
+        isa<VectorBaseAddrInst>(user) ||
         isa<MarkUnresolvedNonCopyableValueInst>(user) ||
         isa<MarkUninitializedInst>(user) || isa<DropDeinitInst>(user) ||
         isa<ProjectBlockStorageInst>(user) || isa<UpcastInst>(user) ||

include/swift/SIL/SILBridging.h

@@ -1258,6 +1258,7 @@ struct BridgedBuilder{
   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 createVectorBaseAddr(BridgedValue vector) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalAddr(BridgedGlobalVar global,
                                                                          OptionalBridgedValue dependencyToken) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createGlobalValue(BridgedGlobalVar global,

include/swift/SIL/SILBridgingImpl.h

@@ -2453,6 +2453,10 @@ BridgedInstruction BridgedBuilder::createVector(BridgedValueArray arguments) con
   return {unbridged().createVector(swift::ArtificialUnreachableLocation(), arguments.getValues(argValues))};
 }
 
+BridgedInstruction BridgedBuilder::createVectorBaseAddr(BridgedValue vector) const {
+  return {unbridged().createVectorBaseAddr(regularLoc(), vector.getSILValue())};
+}
+
 BridgedInstruction BridgedBuilder::createGlobalAddr(BridgedGlobalVar global,
                                                     OptionalBridgedValue dependencyToken) const {
   return {unbridged().createGlobalAddr(regularLoc(), global.getGlobal(), dependencyToken.getSILValue())};

include/swift/SIL/SILBuilder.h

@@ -22,6 +22,7 @@
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILUndef.h"
+#include "swift/SIL/AbstractionPattern.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringExtras.h"
 #include <type_traits>
@@ -1923,6 +1924,15 @@ class SILBuilder {
     return createStructElementAddr(Loc, Operand, Field, ResultTy);
   }
 
+  VectorBaseAddrInst *
+  createVectorBaseAddr(SILLocation loc, SILValue vector) {
+    auto arrayTy = vector->getType().getAs<BuiltinFixedArrayType>();
+    ASSERT(arrayTy && "operand of vector_extract must be a builtin array type");
+    auto elemtTy = getFunction().getLoweredType(Lowering::AbstractionPattern::getOpaque(), arrayTy->getElementType());
+    return insert(new (getModule()) VectorBaseAddrInst(
+        getSILDebugLocation(loc), vector, elemtTy.getAddressType()));
+  }
+
   RefElementAddrInst *createRefElementAddr(SILLocation Loc, SILValue Operand,
                                            VarDecl *Field, SILType ResultTy,
                                            bool IsImmutable = false) {

include/swift/SIL/SILCloner.h

@@ -2542,6 +2542,16 @@ SILCloner<ImplClass>::visitStructElementAddrInst(StructElementAddrInst *Inst) {
                 Inst->getField(), getOpType(Inst->getType())));
 }
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitVectorBaseAddrInst(VectorBaseAddrInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createVectorBaseAddr(
+                getOpLocation(Inst->getLoc()),
+                getOpValue(Inst->getVector())));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitRefElementAddrInst(RefElementAddrInst *Inst) {