SIL: remove the alloc_vector instruction

eeckstein · eeckstein · commit e0b4f71af609 · 2025-02-12T10:51:14.000+01:00
It's not needed anymore, because the "FixedArray" experimental feature is replaced by inline-arrays.
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift
@@ -424,7 +424,6 @@ extension Instruction {
          is FloatLiteralInst,
          is ObjectInst,
          is VectorInst,
-         is AllocVectorInst,
          is UncheckedRefCastInst,
          is UpcastInst,
          is ValueToBridgeObjectInst,
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/SwiftCompilerSources/Sources/SIL/Builder.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)
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.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() }
 
diff --git a/SwiftCompilerSources/Sources/SIL/Registration.swift b/SwiftCompilerSources/Sources/SIL/Registration.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)
diff --git a/docs/SIL/Instructions.md b/docs/SIL/Instructions.md
@@ -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
 
 ```
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -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())};
 }
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.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()));
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.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) {
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.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
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
@@ -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,
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.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()) {
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -1188,7 +1188,6 @@ class IRGenSILFunction :
   void emitDebugInfoForAllocStack(AllocStackInst *i, const TypeInfo &type,
                                   llvm::Value *addr);
   void visitAllocStackInst(AllocStackInst *i);
-  void visitAllocVectorInst(AllocVectorInst *i);
   void visitAllocPackInst(AllocPackInst *i);
   void visitAllocPackMetadataInst(AllocPackMetadataInst *i);
   void visitAllocRefInst(AllocRefInst *i);
@@ -6480,15 +6479,6 @@ void IRGenSILFunction::visitAllocStackInst(swift::AllocStackInst *i) {
   emitDebugInfoForAllocStack(i, type, addr.getAddress());
 }
 
-void IRGenSILFunction::visitAllocVectorInst(AllocVectorInst *i) {
-  const TypeInfo &type = getTypeInfo(i->getElementType());
-  Explosion capacity = getLoweredExplosion(i->getCapacity());
-  auto stackAddr = type.allocateVector(*this, i->getElementType(),
-                                       capacity.claimNext(), StringRef());
-  setLoweredStackAddress(i, stackAddr);
-}
-
-
 void IRGenSILFunction::visitAllocPackInst(swift::AllocPackInst *i) {
   auto addr = allocatePack(*this, i->getPackType());
   setLoweredStackAddress(i, addr);
diff --git a/lib/SIL/IR/OperandOwnership.cpp b/lib/SIL/IR/OperandOwnership.cpp
@@ -151,7 +151,6 @@ OPERAND_OWNERSHIP(TrivialUse, AwaitAsyncContinuation)
 OPERAND_OWNERSHIP(TrivialUse, AddressToPointer)
 OPERAND_OWNERSHIP(TrivialUse, AllocRef)        // with tail operand
 OPERAND_OWNERSHIP(TrivialUse, AllocRefDynamic) // with tail operand
-OPERAND_OWNERSHIP(TrivialUse, AllocVector)
 OPERAND_OWNERSHIP(TrivialUse, BeginAccess)
 OPERAND_OWNERSHIP(TrivialUse, MoveOnlyWrapperToCopyableAddr)
 OPERAND_OWNERSHIP(TrivialUse, CopyableToMoveOnlyWrapperAddr)
diff --git a/lib/SIL/IR/SILInstruction.cpp b/lib/SIL/IR/SILInstruction.cpp
@@ -1277,7 +1277,6 @@ namespace {
 
 bool SILInstruction::isAllocatingStack() const {
   if (isa<AllocStackInst>(this) ||
-      isa<AllocVectorInst>(this) ||
       isa<AllocPackInst>(this) ||
       isa<AllocPackMetadataInst>(this))
     return true;
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -297,25 +297,6 @@ DeallocStackInst *AllocStackInst::getSingleDeallocStack() const {
   return Dealloc;
 }
 
-AllocVectorInst *AllocVectorInst::create(SILDebugLocation Loc, SILValue capacity,
-                                        SILType elementType, SILFunction &F) {
-  SmallVector<SILValue, 8> typeDependentOperands;
-  collectTypeDependentOperands(typeDependentOperands, F, elementType.getASTType());
-  auto size = totalSizeToAlloc<swift::Operand>(1 + typeDependentOperands.size());
-  auto buffer = F.getModule().allocateInst(size, alignof(AllocVectorInst));
-  return ::new (buffer) AllocVectorInst(Loc, capacity, elementType.getAddressType(),
-                                        typeDependentOperands);
-}
-
-AllocVectorInst *AllocVectorInst::createInInitializer(SILDebugLocation Loc,
-                                                      SILValue capacity,
-                                                      SILType elementType,
-                                                      SILModule &M) {
-  auto size = totalSizeToAlloc<swift::Operand>(1);
-  auto buffer = M.allocateInst(size, alignof(AllocVectorInst));
-  return ::new (buffer) AllocVectorInst(Loc, capacity, elementType, {});
-}
-
 AllocPackInst *AllocPackInst::create(SILDebugLocation loc,
                                      SILType packType,
                                      SILFunction &F) {
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1515,9 +1515,6 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     printDebugVar(AVI->getVarInfo(false),
                   &AVI->getModule().getASTContext().SourceMgr);
   }
-  void visitAllocVectorInst(AllocVectorInst *AVI) {
-    *this << AVI->getElementType() << ", " << getIDAndType(AVI->getCapacity());
-  }
   void visitAllocPackInst(AllocPackInst *API) {
     *this << API->getType().getObjectType();
   }
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -105,7 +105,6 @@ CONSTANT_OWNERSHIP_INST(Owned, ObjCMetatypeToObject)
 // not though.
 CONSTANT_OWNERSHIP_INST(None, AddressToPointer)
 CONSTANT_OWNERSHIP_INST(None, AllocStack)
-CONSTANT_OWNERSHIP_INST(None, AllocVector)
 CONSTANT_OWNERSHIP_INST(None, AllocPack)
 CONSTANT_OWNERSHIP_INST(None, AllocPackMetadata)
 CONSTANT_OWNERSHIP_INST(None, PackLength)
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -4988,21 +4988,6 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
                              isFromVarDecl, usesMoveableValueDebugInfo);
     break;
   }
-  case SILInstructionKind::AllocVectorInst: {
-    SILType Ty;
-    if (parseSILType(Ty))
-      return true;
-
-    if (P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ","))
-      return true;
-
-    SILValue capacity;
-    if (parseTypedValueRef(capacity, B))
-      return true;
-
-    ResultVal = B.createAllocVector(InstLoc, capacity, Ty);
-    break;
-  }
   case SILInstructionKind::MetatypeInst: {
     SILType Ty;
     if (parseSILType(Ty))
diff --git a/lib/SIL/Utils/InstructionUtils.cpp b/lib/SIL/Utils/InstructionUtils.cpp
@@ -782,7 +782,6 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
     return RuntimeEffect::MetaData;
 
   case SILInstructionKind::AllocStackInst:
-  case SILInstructionKind::AllocVectorInst:
   case SILInstructionKind::ProjectBoxInst: {
     SILType allocType = cast<SingleValueInstruction>(inst)->getType();
     if (allocType.hasArchetype() && !allocType.isLoadable(*inst->getFunction())) {
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -1801,13 +1801,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     // It's illegal code but the compiler should not crash on it.
   }
 
-  void checkAllocVectorInst(AllocVectorInst *AI) {
-    require(AI->getType().isAddress(),
-            "result of alloc_vector must be an address type");
-    require(AI->getOperand()->getType().is<BuiltinIntegerType>(),
-            "capacity needs integer type");
-  }
-
   void checkAllocPackInst(AllocPackInst *AI) {
     requireAddressType(SILPackType, AI->getType(),
                        "result of alloc_pack must be an address of "
@@ -3804,13 +3797,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     };
     require(isa<SILUndef>(DI->getOperand()) ||
                 isa<AllocStackInst>(DI->getOperand()) ||
-                isa<AllocVectorInst>(DI->getOperand()) ||
                 (isa<PartialApplyInst>(DI->getOperand()) &&
                  cast<PartialApplyInst>(DI->getOperand())->isOnStack()) ||
                 (isTokenFromCalleeAllocatedBeginApply(DI->getOperand())),
-            "Operand of dealloc_stack must be an alloc_stack, alloc_vector or "
-            "partial_apply "
-            "[stack]");
+            "Operand of dealloc_stack must be an alloc_stack or partial_apply [stack]");
   }
   void checkDeallocPackInst(DeallocPackInst *DI) {
     require(isa<SILUndef>(DI->getOperand()) ||
diff --git a/lib/SILOptimizer/Analysis/RegionAnalysis.cpp b/lib/SILOptimizer/Analysis/RegionAnalysis.cpp
@@ -2939,7 +2939,6 @@ CONSTANT_TRANSLATION(AllocBoxInst, AssignFresh)
 CONSTANT_TRANSLATION(AllocPackInst, AssignFresh)
 CONSTANT_TRANSLATION(AllocRefDynamicInst, AssignFresh)
 CONSTANT_TRANSLATION(AllocRefInst, AssignFresh)
-CONSTANT_TRANSLATION(AllocVectorInst, AssignFresh)
 CONSTANT_TRANSLATION(KeyPathInst, AssignFresh)
 CONSTANT_TRANSLATION(FunctionRefInst, AssignFresh)
 CONSTANT_TRANSLATION(DynamicFunctionRefInst, AssignFresh)
diff --git a/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp b/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp
@@ -114,7 +114,6 @@ static bool hasOpaqueArchetype(TypeExpansionContext context,
   // Check substitution maps.
   switch (inst.getKind()) {
   case SILInstructionKind::AllocStackInst:
-  case SILInstructionKind::AllocVectorInst:
   case SILInstructionKind::AllocPackInst:
   case SILInstructionKind::AllocPackMetadataInst:
   case SILInstructionKind::AllocRefInst:
diff --git a/lib/SILOptimizer/Utils/SILInliner.cpp b/lib/SILOptimizer/Utils/SILInliner.cpp
@@ -1043,7 +1043,6 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::AllocRefInst:
   case SILInstructionKind::AllocRefDynamicInst:
   case SILInstructionKind::AllocStackInst:
-  case SILInstructionKind::AllocVectorInst:
   case SILInstructionKind::AllocPackInst:
   case SILInstructionKind::AllocPackMetadataInst:
   case SILInstructionKind::BeginApplyInst:
diff --git a/lib/SILOptimizer/Utils/StackNesting.cpp b/lib/SILOptimizer/Utils/StackNesting.cpp
@@ -209,10 +209,10 @@ static SILInstruction *createDealloc(SILInstruction *Alloc,
   SILBuilderWithScope B(InsertionPoint);
   switch (Alloc->getKind()) {
     case SILInstructionKind::PartialApplyInst:
-      assert(cast<PartialApplyInst>(Alloc)->isOnStack() && "wrong instruction");
-      LLVM_FALLTHROUGH;
     case SILInstructionKind::AllocStackInst:
-    case SILInstructionKind::AllocVectorInst:
+      assert((isa<AllocStackInst>(Alloc) ||
+              cast<PartialApplyInst>(Alloc)->isOnStack()) &&
+             "wrong instruction");
       return B.createDeallocStack(Location,
                                   cast<SingleValueInstruction>(Alloc));
     case SILInstructionKind::BeginApplyInst: {
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1707,16 +1707,6 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
         Attr == 0 ? OpenedExistentialAccess::Immutable
                   : OpenedExistentialAccess::Mutable);
     break;
-  case SILInstructionKind::AllocVectorInst:
-    assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
-           "Layout should be OneTypeOneOperand.");
-    ResultInst = Builder.createAllocVector(
-        Loc,
-        getLocalValue(
-            Builder.maybeGetFunction(), ValID,
-            getSILType(MF->getType(TyID2), (SILValueCategory)TyCategory2, Fn)),
-        getSILType(MF->getType(TyID), (SILValueCategory)TyCategory, Fn));
-    break;
   case SILInstructionKind::DynamicPackIndexInst: {
     assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
            "Layout should be OneTypeOneOperand.");
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 920; // concurrent revert
+const uint16_t SWIFTMODULE_VERSION_MINOR = 921; // remove alloc_vector
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1963,13 +1963,6 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
                                  open.getOperand());
     break;
   }
-  case SILInstructionKind::AllocVectorInst: {
-    auto &avi = cast<AllocVectorInst>(SI);
-    assert(avi.getNumOperands() - avi.getTypeDependentOperands().size() == 1);
-    writeOneTypeOneOperandLayout(avi.getKind(), /*attrs*/ 0, avi.getType(),
-                                 avi.getOperand());
-    break;
-  }
   case SILInstructionKind::DynamicPackIndexInst: {
     auto &dpii = cast<DynamicPackIndexInst>(SI);
     writeOneTypeOneOperandLayout(dpii.getKind(), 0,
diff --git a/test/Concurrency/transfernonsendable_instruction_matching.sil b/test/Concurrency/transfernonsendable_instruction_matching.sil
diff --git a/test/IRGen/static_initializer.sil b/test/IRGen/static_initializer.sil
diff --git a/test/SIL/Parser/basic.sil b/test/SIL/Parser/basic.sil
diff --git a/test/Serialization/Inputs/def_basic.sil b/test/Serialization/Inputs/def_basic.sil

Original file line number	Diff line number	Diff line change
`@@ -1275,10 +1275,6 @@ final public class AllocStackInst : SingleValueInstruction, Allocation, DebugVar`
`1275`	`1275`	`}`
`1276`	`1276`	`}`
`1277`	`1277`
`1278`		`-final public class AllocVectorInst : SingleValueInstruction, Allocation, UnaryInstruction {`
`1279`		`- public var capacity: Value { operand.value }`
`1280`		`-}`
`1281`		`-`
`1282`	`1278`	`public class AllocRefInstBase : SingleValueInstruction, Allocation {`
`1283`	`1279`	`final public var isObjC: Bool { bridged.AllocRefInstBase_isObjc() }`
`1284`	`1280`
Original file line number	Diff line number	Diff line change
`@@ -2003,10 +2003,6 @@ BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,`
`2003`	`2003`	`swift::UsesMoveableValueDebugInfo_t(wasMoved), /skipVarDeclAssert=/ true)};`
`2004`	`2004`	`}`
`2005`	`2005`
`2006`		`-BridgedInstruction BridgedBuilder::createAllocVector(BridgedValue capacity, BridgedType type) const {`
`2007`		`- return {unbridged().createAllocVector(regularLoc(), capacity.getSILValue(), type.unbridged())};`
`2008`		`-}`
`2009`		`-`
`2010`	`2006`	`BridgedInstruction BridgedBuilder::createDeallocStack(BridgedValue operand) const {`
`2011`	`2007`	`return {unbridged().createDeallocStack(regularLoc(), operand.getSILValue())};`
`2012`	`2008`	`}`