Re-instate the allocVector builtin

include/swift/AST/Builtins.def

@@ -638,6 +638,11 @@ BUILTIN_MISC_OPERATION(UnprotectedStackAlloc, "unprotectedStackAlloc", "", Speci
 /// Builtin.stackAlloc(), is deallocated from the stack.
 BUILTIN_MISC_OPERATION(StackDealloc, "stackDealloc", "", Special)
 
+// Obsolete: only there to be able to read old Swift.interface files which still
+// contain the builtin.
+/// allocVector<Element>(Element.Type, Builtin.Word) -> Builtin.RawPointer
+BUILTIN_MISC_OPERATION(AllocVector, "allocVector", "", Special)
+
 /// Fence has type () -> ().
 BUILTIN_MISC_OPERATION(Fence, "fence", "", None)
 

lib/AST/Builtins.cpp

@@ -1137,6 +1137,15 @@ static ValueDecl *getStackDeallocOperation(ASTContext &ctx, Identifier id) {
                             _void);
 }
 
+// Obsolete: only there to be able to read old Swift.interface files which still
+// contain the builtin.
+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);
 }
@@ -3042,6 +3051,9 @@ 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/IRGen/GenBuiltin.cpp

@@ -1475,6 +1475,17 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return;
   }
 
+  if (Builtin.ID == BuiltinValueKind::AllocVector) {
+    // Obsolete: only there to be able to read old Swift.interface files which still
+    // contain the builtin.
+    (void)args.claimAll();
+    IGF.emitTrap("vector allocation not supported anymore", /*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/SIL/IR/OperandOwnership.cpp

@@ -866,6 +866,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, SSubOver)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, StackAlloc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, UnprotectedStackAlloc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, StackDealloc)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, AllocVector)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, SToSCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, SToUCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Expect)

lib/SIL/IR/ValueOwnership.cpp

@@ -560,6 +560,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, UToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(None, StackAlloc)
 CONSTANT_OWNERSHIP_BUILTIN(None, UnprotectedStackAlloc)
 CONSTANT_OWNERSHIP_BUILTIN(None, StackDealloc)
+CONSTANT_OWNERSHIP_BUILTIN(None, AllocVector)
 CONSTANT_OWNERSHIP_BUILTIN(None, SToSCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(None, SToUCheckedTrunc)
 CONSTANT_OWNERSHIP_BUILTIN(None, UToUCheckedTrunc)

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -157,6 +157,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::StackAlloc:
     case BuiltinValueKind::UnprotectedStackAlloc:
     case BuiltinValueKind::StackDealloc:
+    case BuiltinValueKind::AllocVector:
     case BuiltinValueKind::AssumeAlignment:
     case BuiltinValueKind::GetEnumTag:
     case BuiltinValueKind::InjectEnumTag:

test/IRGen/builtins.swift

@@ -861,4 +861,13 @@ func injectEnumTag<T>(_ x: inout T, tag: UInt32) {
   Builtin.injectEnumTag(&x, tag._value)
 }
 
+// Check that we still support the obsolete allocVector builtin in old Swift.interface files.
+
+// CHECK-LABEL: define {{.*}} swiftcc ptr @"$s8builtins14allocateVector11elementType8capacityBpxm_BwtlF"
+// CHECK:       trap()
+// CHECK:       unreachable
+func allocateVector<Element>(elementType: Element.Type, capacity: Builtin.Word) -> Builtin.RawPointer {
+  return Builtin.allocVector(elementType, capacity)
+}
+
 // CHECK: ![[R]] = !{i64 0, i64 9223372036854775807}