Merge pull request #79317 from eeckstein/remove-alloc-vector

Remove the experimental FixedArray

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -7,7 +7,6 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
-  AllocVectorLowering.swift
   AssumeSingleThreaded.swift
   AsyncDemotion.swift
   BooleanLiteralFolding.swift

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -47,7 +47,6 @@ extension BuiltinInst : OnoneSimplifiable {
            .AssignCopyArrayFrontToBack,
            .AssignCopyArrayBackToFront,
            .AssignTakeArray,
-           .AllocVector,
            .IsPOD:
         optimizeArgumentToThinMetatype(argument: 0, context)
       case .ICMP_EQ:

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -68,7 +68,6 @@ private func registerSwiftPasses() {
   registerPass(stackProtection, { stackProtection.run($0) })
 
   // Function passes
-  registerPass(allocVectorLowering, { allocVectorLowering.run($0) })
   registerPass(asyncDemotion, { asyncDemotion.run($0) })
   registerPass(booleanLiteralFolding, { booleanLiteralFolding.run($0) })
   registerPass(letPropertyLowering, { letPropertyLowering.run($0) })

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -424,7 +424,6 @@ extension Instruction {
          is FloatLiteralInst,
          is ObjectInst,
          is VectorInst,
-         is AllocVectorInst,
          is UncheckedRefCastInst,
          is UpcastInst,
          is ValueToBridgeObjectInst,

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -130,11 +130,6 @@ 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)

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -1275,10 +1275,6 @@ 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/Instruction.swift

@@ -226,7 +226,6 @@ public func registerSILClasses() {
   register(IsUniqueInst.self)
   register(DestroyNotEscapedClosureInst.self)
   register(AllocStackInst.self)
-  register(AllocVectorInst.self)
   register(AllocPackInst.self)
   register(AllocPackMetadataInst.self)
   register(AllocRefInst.self)

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -55,27 +55,6 @@ 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
 
 ```

docs/SIL/Instructions.md

@@ -638,9 +638,6 @@ BUILTIN_MISC_OPERATION(UnprotectedStackAlloc, "unprotectedStackAlloc", "", Speci
 /// Builtin.stackAlloc(), is deallocated from the stack.
 BUILTIN_MISC_OPERATION(StackDealloc, "stackDealloc", "", Special)
 
-/// allocVector<Element>(Element.Type, Builtin.Word) -> Builtin.RawPointer
-BUILTIN_MISC_OPERATION(AllocVector, "allocVector", "", Special)
-
 /// Fence has type () -> ().
 BUILTIN_MISC_OPERATION(Fence, "fence", "", None)
 

include/swift/AST/Builtins.def

@@ -1141,12 +1141,6 @@ NOTE(rbi_add_generic_parameter_sendable_conformance,none,
 ERROR(deinit_not_visible, none,
       "deinit of non-copyable type not visible in the current module", ())
 
-ERROR(vector_capacity_not_constant, none,
-      "vector capacity needs to be constant", ())
-
-ERROR(fixed_arrays_not_available, none,
-      "fixed arrays are only available with -enable-experimental-feature FixedArrays", ())
-
 ERROR(lifetime_variable_outside_scope, none,
       "lifetime-dependent variable '%0' escapes its scope", (Identifier))
 ERROR(lifetime_value_outside_scope, none,

include/swift/AST/DiagnosticsSIL.def

@@ -64,7 +64,6 @@ SEMANTICS_ATTR(ARRAY_DEALLOC_UNINITIALIZED, "array.dealloc_uninitialized")
 SEMANTICS_ATTR(ARRAY_UNINITIALIZED_INTRINSIC, "array.uninitialized_intrinsic")
 SEMANTICS_ATTR(ARRAY_FINALIZE_INTRINSIC, "array.finalize_intrinsic")
 SEMANTICS_ATTR(ARRAY_GET_CONTIGUOUSARRAYSTORAGETYPE, "array.getContiguousArrayStorageType")
-SEMANTICS_ATTR(ARRAY_COPY_INTO_VECTOR, "array.copy_into_vector")
 
 SEMANTICS_ATTR(SEQUENCE_FOR_EACH, "sequence.forEach")
 SEMANTICS_ATTR(TYPENAME, "typeName")

include/swift/AST/SemanticAttrs.def

@@ -158,7 +158,6 @@ BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncTaskWithExecutor, 0, "Task create bu
 BASELINE_LANGUAGE_FEATURE(BuiltinCreateAsyncDiscardingTaskInGroupWithExecutor, 0, "Task create in discarding task group with extra executor preference")
 BASELINE_LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc")
 BASELINE_LANGUAGE_FEATURE(BuiltinUnprotectedStackAlloc, 0, "Builtin.unprotectedStackAlloc")
-BASELINE_LANGUAGE_FEATURE(BuiltinAllocVector, 0, "Builtin.allocVector")
 BASELINE_LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline")
 BASELINE_LANGUAGE_FEATURE(BuiltinUnprotectedAddressOf, 0, "Builtin.unprotectedAddressOf")
 BASELINE_LANGUAGE_FEATURE(NewCxxMethodSafetyHeuristics, 0, "Only import C++ methods that return pointers (projections) on owned types as unsafe")
@@ -367,9 +366,6 @@ EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
 /// Enable the @extractConstantsFromMembers attribute.
 EXPERIMENTAL_FEATURE(ExtractConstantsFromMembers, false)
 
-/// Enables the FixedArray data type.
-EXPERIMENTAL_FEATURE(FixedArrays, true)
-
 // Group Main Actor Isolation Errors by Scope
 EXPERIMENTAL_FEATURE(GroupActorErrors, true)
 

include/swift/Basic/Features.def

@@ -2003,10 +2003,6 @@ BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,
       swift::UsesMoveableValueDebugInfo_t(wasMoved), /*skipVarDeclAssert=*/ true)};
 }
 
-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())};
 }

include/swift/SIL/SILBridgingImpl.h

@@ -437,16 +437,6 @@ class SILBuilder {
         isFromVarDecl, 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()));

include/swift/SIL/SILBuilder.h

@@ -1052,17 +1052,6 @@ 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) {

include/swift/SIL/SILCloner.h

@@ -2213,35 +2213,6 @@ 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

include/swift/SIL/SILInstruction.h

@@ -313,8 +313,6 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   ABSTRACT_SINGLE_VALUE_INST(AllocationInst, SingleValueInstruction)
     SINGLE_VALUE_INST(AllocStackInst, alloc_stack,
                               AllocationInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(AllocVectorInst, alloc_vector,
-                              AllocationInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(AllocPackInst, alloc_pack,
                               AllocationInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(AllocPackMetadataInst, alloc_pack_metadata,

include/swift/SIL/SILNodes.def

@@ -37,7 +37,6 @@ enum class ArrayCallKind {
   kWithUnsafeMutableBufferPointer,
   kAppendContentsOf,
   kAppendElement,
-  kCopyIntoVector,
   // The following two semantic function kinds return the result @owned
   // instead of operating on self passed as parameter. If you are adding
   // a function, and it has a self parameter, make sure that it is defined
@@ -46,7 +45,7 @@ enum class ArrayCallKind {
   kArrayInitEmpty,
   kArrayUninitialized,
   kArrayUninitializedIntrinsic,
-  kArrayFinalizeIntrinsic,
+  kArrayFinalizeIntrinsic
 };
 
 /// Return true is the given function is an array semantics call.

include/swift/SILOptimizer/Analysis/ArraySemantic.h

@@ -429,8 +429,6 @@ SWIFT_FUNCTION_PASS(NamedReturnValueOptimization, "named-return-value-optimizati
     "Optimize copies to an indirect return value")
 SWIFT_FUNCTION_PASS(StripObjectHeaders, "strip-object-headers",
     "Sets the bare flag on objects which don't need their headers")
-SWIFT_FUNCTION_PASS(AllocVectorLowering, "alloc-vector-lowering",
-     "lowering of allocVector builtins")
 PASS(SimplifyBBArgs, "simplify-bb-args",
      "SIL Block Argument Simplification")
 PASS(SimplifyCFG, "simplify-cfg",

include/swift/SILOptimizer/PassManager/Passes.def

@@ -1137,13 +1137,6 @@ static ValueDecl *getStackDeallocOperation(ASTContext &ctx, Identifier id) {
                             _void);
 }
 
-static ValueDecl *getAllocVectorOperation(ASTContext &ctx, Identifier id) {
-  return getBuiltinFunction(ctx, id, _thin,
-                            _generics(_unrestricted),
-                            _parameters(_metatype(_typeparam(0)), _word),
-                            _rawPointer);
-}
-
 static ValueDecl *getFenceOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin, _parameters(), _void);
 }
@@ -3049,9 +3042,6 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::StackDealloc:
     return getStackDeallocOperation(Context, Id);
 
-  case BuiltinValueKind::AllocVector:
-    return getAllocVectorOperation(Context, Id);
-
   case BuiltinValueKind::CastToNativeObject:
   case BuiltinValueKind::UnsafeCastToNativeObject:
   case BuiltinValueKind::CastFromNativeObject:

lib/AST/Builtins.cpp

@@ -193,7 +193,6 @@ static bool usesFeatureNonescapableTypes(Decl *decl) {
 
 UNINTERESTING_FEATURE(StaticExclusiveOnly)
 UNINTERESTING_FEATURE(ExtractConstantsFromMembers)
-UNINTERESTING_FEATURE(FixedArrays)
 UNINTERESTING_FEATURE(GroupActorErrors)
 UNINTERESTING_FEATURE(SameElementRequirements)
 UNINTERESTING_FEATURE(UnspecifiedMeansMainActorIsolated)

lib/AST/FeatureSet.cpp

@@ -83,8 +83,6 @@ class FixedTypeInfo : public TypeInfo {
 
   StackAddress allocateStack(IRGenFunction &IGF, SILType T,
                              const llvm::Twine &name) const override;
-  StackAddress allocateVector(IRGenFunction &IGF, SILType T,
-                              llvm::Value *capacity, const Twine &name) const override;
   void deallocateStack(IRGenFunction &IGF, StackAddress addr, SILType T) const override;
   void destroyStack(IRGenFunction &IGF, StackAddress addr, SILType T,
                     bool isOutlined) const override;

lib/IRGen/FixedTypeInfo.h

@@ -625,12 +625,6 @@ class NonFixedArrayTypeInfo final
     return alloca.withAddress(getAddressForPointer(alloca.getAddressPointer()));
   }
 
-  StackAddress allocateVector(IRGenFunction &IGF, SILType T,
-                              llvm::Value *capacity,
-                              const Twine &name) const override {
-    llvm_unreachable("not implemented, yet");
-  }
-
   void deallocateStack(IRGenFunction &IGF, StackAddress stackAddress,
                        SILType T) const override {
     IGF.Builder.CreateLifetimeEnd(stackAddress.getAddress().getAddress());

lib/IRGen/GenArray.cpp

@@ -1475,15 +1475,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
-  if (Builtin.ID == BuiltinValueKind::AllocVector) {
-    (void)args.claimAll();
-    IGF.emitTrap("escaped vector allocation", /*EmitUnreachable=*/true);
-    out.add(llvm::UndefValue::get(IGF.IGM.Int8PtrTy));
-    llvm::BasicBlock *contBB = llvm::BasicBlock::Create(IGF.IGM.getLLVMContext());
-    IGF.Builder.emitBlock(contBB);
-    return;
-  }
-
   if (Builtin.ID == BuiltinValueKind::GetEnumTag) {
     auto arg = args.claimNext();
     auto ty = argTypes[0];

lib/IRGen/GenBuiltin.cpp

@@ -2833,20 +2833,6 @@ llvm::Constant *IRGenModule::getGlobalInitValue(SILGlobalVariable *var,
   }
   if (SILInstruction *initInst = var->getStaticInitializerValue()) {
 
-    if (auto *vector = dyn_cast<AllocVectorInst>(initInst)) {
-      auto *capacityConst = emitConstantValue(*this, vector->getCapacity()).claimNextConstant();
-      uint64_t capacity = cast<llvm::ConstantInt>(capacityConst)->getZExtValue();
-      auto &ti = cast<FixedTypeInfo>(getTypeInfo(vector->getType()));
-      auto *elementTy = cast<llvm::StructType>(ti.getStorageType());
-      Size::int_type paddingBytes = (ti.getFixedStride() - ti.getFixedSize()).getValue();
-      if (paddingBytes != 0) {
-        llvm::ArrayType *padding = llvm::ArrayType::get(Int8Ty, paddingBytes);
-        elementTy = llvm::StructType::get(getLLVMContext(), {elementTy, padding});
-      }
-      auto *arrayTy = llvm::ArrayType::get(elementTy, capacity);
-      return llvm::ConstantAggregateZero::get(arrayTy);
-    }
-
     if (auto *vector = dyn_cast<VectorInst>(initInst)) {
       llvm::SmallVector<llvm::Constant *, 8> elementValues;
       for (SILValue element : vector->getElements()) {

lib/IRGen/GenDecl.cpp

@@ -74,23 +74,6 @@ StackAddress FixedTypeInfo::allocateStack(IRGenFunction &IGF, SILType T,
   return { alloca };
 }
 
-StackAddress FixedTypeInfo::allocateVector(IRGenFunction &IGF, SILType T,
-                                           llvm::Value *capacity,
-                                           const Twine &name) const {
-  // If the type is known to be empty, don't actually allocate anything.
-  if (isKnownEmpty(ResilienceExpansion::Maximal)) {
-    auto addr = getUndefAddress();
-    return { addr };
-  }
-
-  StackAddress alloca =
-    IGF.emitDynamicAlloca(getStorageType(), capacity, getFixedAlignment(),
-                          /*allowTaskAlloc*/ true, name);
-  IGF.Builder.CreateLifetimeStart(alloca.getAddress(), getFixedSize());
-
-  return { alloca };
-}
-
 void FixedTypeInfo::destroyStack(IRGenFunction &IGF, StackAddress addr,
                                  SILType T, bool isOutlined) const {
   destroy(IGF, addr.getAddress(), T, isOutlined);

lib/IRGen/GenInit.cpp

@@ -1378,11 +1378,6 @@ namespace {
                                const llvm::Twine &name) const override {
       llvm_unreachable("should not call on an immovable opaque type");
     }
-    StackAddress allocateVector(IRGenFunction &IGF, SILType T,
-                                llvm::Value *capacity,
-                                const Twine &name) const override {
-      llvm_unreachable("should not call on an immovable opaque type");
-    }
     void deallocateStack(IRGenFunction &IGF, StackAddress addr,
                          SILType T) const override {
       llvm_unreachable("should not call on an immovable opaque type");