[NO MERGE] implement realloc_ref SIL instruction [INCOMPLETE]

include/swift/SIL/SILBuilder.h

@@ -385,6 +385,19 @@ class SILBuilder {
                                        C.OpenedArchetypes));
   }
 
+  ReallocRefInst *createReallocRef(SILLocation Loc, SILType ObjectType,
+                                   SILValue Val, ArrayRef<SILType> ElementTypes,
+                                   ArrayRef<SILValue> ElementCountOperands) {
+    // ReallocRefInst expand to function calls and can therefore not be
+    // counted towards the function prologue.
+    assert(!Loc.isInPrologue() &&
+           "ReallocRefInst can not count towards function prologue since it "
+           "expands into function calls");
+    return insert(ReallocRefInst::create(
+        getSILDebugLocation(Loc), getFunction(), ObjectType, Val, ElementTypes,
+        ElementCountOperands, C.OpenedArchetypes));
+  }
+
   AllocRefDynamicInst *createAllocRefDynamic(SILLocation Loc, SILValue operand,
                                              SILType type, bool objc,
                                     ArrayRef<SILType> ElementTypes,

include/swift/SIL/SILCloner.h

@@ -500,6 +500,11 @@ SILCloner<ImplClass>::visitAllocRefInst(AllocRefInst *Inst) {
   doPostProcess(Inst, NewInst);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitReallocRefInst(ReallocRefInst *Inst) {
+  llvm_unreachable("unimplemented: incomplete realloc_ref implementation");
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitAllocRefDynamicInst(AllocRefDynamicInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -1446,6 +1446,55 @@ class AllocRefInst final
   }
 };
 
+/// ReallocRefInst - This represents the reallocation primitive of a reference
+/// type. If the reallocation was successfully the reference is returned with
+/// the altered size. If the reallocation failed the reference is returned at
+/// a new address in an allocation with the altered size and the contents are
+/// bit-wise copied.
+/// This is only useful for tail-allocated arrays and the new size must always
+/// be larger than the original size.
+class ReallocRefInst final
+    : public InstructionBaseWithTrailingOperands<
+                                               SILInstructionKind::ReallocRefInst,
+                                               ReallocRefInst,
+                                               AllocRefInstBase, SILType> {
+  friend AllocRefInstBase;
+  friend SILBuilder;
+
+  ReallocRefInst(SILDebugLocation DebugLoc, SILFunction &F, SILType ObjectType,
+                 SILValue ExistingRef, ArrayRef<SILType> ElementTypes,
+                 ArrayRef<SILValue> AllOperands)
+      : InstructionBaseWithTrailingOperands(AllOperands, DebugLoc, ObjectType,
+                                            false, false, ElementTypes) {
+    assert(AllOperands.size() >= ElementTypes.size());
+    std::uninitialized_copy(ElementTypes.begin(), ElementTypes.end(),
+                            getTrailingObjects<SILType>());
+  }
+
+  static ReallocRefInst *create(SILDebugLocation DebugLoc, SILFunction &F,
+                                SILType ObjectType, SILValue ExistingRef,
+                                ArrayRef<SILType> ElementTypes,
+                                ArrayRef<SILValue> ElementCountOperands,
+                                SILOpenedArchetypesState &OpenedArchetypes);
+
+public:
+  ArrayRef<Operand> getTypeDependentOperands() const {
+    return getAllOperands().slice(getNumTailTypes());
+  }
+
+  MutableArrayRef<Operand> getTypeDependentOperands() {
+    return getAllOperands().slice(getNumTailTypes());
+  }
+
+  SILValue getReallocPointer() {
+    llvm_unreachable("Unimplemented! realloc_ref implementation incomplete");
+  }
+
+  SILValue getReallocSize() {
+    llvm_unreachable("Unimplemented! realloc_ref implementation incomplete");
+  }
+};
+
 /// AllocRefDynamicInst - This represents the primitive allocation of
 /// an instance of a reference type whose runtime type is provided by
 /// the given metatype value. Aside from the reference count, the

include/swift/SIL/SILNodes.def

@@ -231,6 +231,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       AllocationInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(AllocRefInst, alloc_ref,
                       AllocationInst, None, DoesNotRelease)
+    SINGLE_VALUE_INST(ReallocRefInst, realloc_ref,
+                      AllocationInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(AllocRefDynamicInst, alloc_ref_dynamic,
                       AllocationInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(AllocValueBufferInst, alloc_value_buffer,

include/swift/Serialization/ModuleFormat.h

@@ -55,7 +55,7 @@ const uint16_t 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 VERSION_MINOR = 426; // SIL key path external components with local attempts
+const uint16_t VERSION_MINOR = 427; // Last change: add realloc_ref
 
 using DeclIDField = BCFixed<31>;
 

lib/IRGen/IRGenSIL.cpp

@@ -919,6 +919,7 @@ class IRGenSILFunction :
                                   llvm::Value *addr);
   void visitAllocStackInst(AllocStackInst *i);
   void visitAllocRefInst(AllocRefInst *i);
+  void visitReallocRefInst(ReallocRefInst *i);
   void visitAllocRefDynamicInst(AllocRefDynamicInst *i);
   void visitAllocBoxInst(AllocBoxInst *i);
 
@@ -4095,6 +4096,10 @@ void IRGenSILFunction::visitAllocRefInst(swift::AllocRefInst *i) {
   setLoweredExplosion(i, e);
 }
 
+void IRGenSILFunction::visitReallocRefInst(swift::ReallocRefInst *i) {
+  llvm_unreachable("unimplemented: incomplete realloc_ref implementation");
+}
+
 void IRGenSILFunction::visitAllocRefDynamicInst(swift::AllocRefDynamicInst *i) {
   SmallVector<std::pair<SILType, llvm::Value *>, 4> TailArrays;
   buildTailArrays(*this, TailArrays, i);

lib/ParseSIL/ParseSIL.cpp

@@ -3602,6 +3602,47 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     }
     break;
   }
+  case SILInstructionKind::ReallocRefInst: {
+    SmallVector<SILType, 2> ElementTypes;
+    SmallVector<SILValue, 2> ElementCounts;
+    while (P.consumeIf(tok::l_square)) {
+      Identifier Id;
+      parseSILIdentifier(Id, diag::expected_in_attribute_list);
+      StringRef Optional = Id.str();
+      if (Optional == "tail_elems") {
+        SILType ElemTy;
+        if (parseSILType(ElemTy) || !P.Tok.isAnyOperator() ||
+            P.Tok.getText() != "*")
+          return true;
+        P.consumeToken();
+
+        SILValue ElemCount;
+        if (parseTypedValueRef(ElemCount, B))
+          return true;
+
+        ElementTypes.push_back(ElemTy);
+        ElementCounts.push_back(ElemCount);
+      } else {
+        return true;
+      }
+      P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+    }
+    SILValue Metadata;
+    if (parseTypedValueRef(Val, B) ||
+        P.parseToken(tok::comma, diag::expected_tok_in_sil_instr, ","))
+      return true;
+
+    SILType ObjectType;
+    if (parseSILType(ObjectType))
+      return true;
+
+    if (parseSILDebugLocation(InstLoc, B))
+      return true;
+
+    ResultVal = B.createReallocRef(InstLoc, ObjectType, Val, ElementTypes,
+                                   ElementCounts);
+    break;
+  }
   case SILInstructionKind::AllocRefInst:
   case SILInstructionKind::AllocRefDynamicInst: {
     bool IsObjC = false;

lib/SIL/Linker.cpp

@@ -353,6 +353,18 @@ void SILLinkerVisitor::visitAllocRefInst(AllocRefInst *ARI) {
   linkInVTable(D);
 }
 
+void SILLinkerVisitor::visitReallocRefInst(ReallocRefInst *RRI) {
+  if (!isLinkAll())
+    return;
+
+  // Grab the class decl from the alloc ref inst.
+  ClassDecl *D = RRI->getType().getClassOrBoundGenericClass();
+  if (!D)
+    return;
+
+  linkInVTable(D);
+}
+
 void SILLinkerVisitor::visitMetatypeInst(MetatypeInst *MI) {
   if (!isLinkAll())
     return;

lib/SIL/Linker.h

@@ -75,6 +75,7 @@ class SILLinkerVisitor : public SILInstructionVisitor<SILLinkerVisitor, void> {
   void visitInitExistentialAddrInst(InitExistentialAddrInst *IEI);
   void visitInitExistentialRefInst(InitExistentialRefInst *IERI);
   void visitAllocRefInst(AllocRefInst *ARI);
+  void visitReallocRefInst(ReallocRefInst *RRI);
   void visitMetatypeInst(MetatypeInst *MI);
 
 private:

lib/SIL/SILInstruction.cpp

@@ -367,6 +367,8 @@ namespace {
       return true;
     }
 
+    bool visitReallocRefInst(const ReallocRefInst *RHS) { return true; }
+
     bool visitAllocRefDynamicInst(const AllocRefDynamicInst *RHS) {
       return true;
     }

lib/SIL/SILInstructions.cpp

@@ -232,6 +232,27 @@ AllocRefInst *AllocRefInst::create(SILDebugLocation Loc, SILFunction &F,
                                      ElementTypes, AllOperands);
 }
 
+ReallocRefInst *
+ReallocRefInst::create(SILDebugLocation Loc, SILFunction &F, SILType ObjectType,
+                       SILValue ExistingRef, ArrayRef<SILType> ElementTypes,
+                       ArrayRef<SILValue> ElementCountOperands,
+                       SILOpenedArchetypesState &OpenedArchetypes) {
+  assert(ElementTypes.size() == ElementCountOperands.size());
+  SmallVector<SILValue, 8> AllOperands(ElementCountOperands.begin(),
+                                       ElementCountOperands.end());
+  for (SILType ElemType : ElementTypes) {
+    collectTypeDependentOperands(AllOperands, OpenedArchetypes, F,
+                                 ElemType.getASTType());
+  }
+  collectTypeDependentOperands(AllOperands, OpenedArchetypes, F,
+                               ObjectType.getASTType());
+  auto Size = totalSizeToAlloc<swift::Operand, SILType>(AllOperands.size(),
+                                                        ElementTypes.size());
+  auto Buffer = F.getModule().allocateInst(Size, alignof(ReallocRefInst));
+  return ::new (Buffer) ReallocRefInst(Loc, F, ObjectType, ExistingRef,
+                                       ElementTypes, AllOperands);
+}
+
 AllocRefDynamicInst *
 AllocRefDynamicInst::create(SILDebugLocation DebugLoc, SILFunction &F,
                             SILValue metatypeOperand, SILType ty, bool objc,

lib/SIL/SILOwnershipVerifier.cpp

@@ -645,6 +645,17 @@ OwnershipCompatibilityUseChecker::visitAllocRefInst(AllocRefInst *I) {
           UseLifetimeConstraint::MustBeLive};
 }
 
+OwnershipUseCheckerResult
+OwnershipCompatibilityUseChecker::visitReallocRefInst(ReallocRefInst *I) {
+  if (getValue() == I->getReallocPointer()) {
+    return {compatibleWithOwnership(ValueOwnershipKind::Owned),
+            UseLifetimeConstraint::MustBeInvalidated};
+  }
+  assert(getValue() == I->getReallocSize());
+  return {compatibleWithOwnership(ValueOwnershipKind::Trivial),
+          UseLifetimeConstraint::MustBeLive};
+}
+
 OwnershipUseCheckerResult
 OwnershipCompatibilityUseChecker::visitAllocRefDynamicInst(
     AllocRefDynamicInst *I) {

lib/SIL/SILPrinter.cpp

@@ -1050,6 +1050,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << ARI->getType();
   }
 
+  void visitReallocRefInst(ReallocRefInst *RRI) {
+    printAllocRefInstBase(RRI);
+    *this << RRI->getType();
+  }
+
   void visitAllocRefDynamicInst(AllocRefDynamicInst *ARDI) {
     printAllocRefInstBase(ARDI);
     *this << getIDAndType(ARDI->getMetatypeOperand());

lib/SIL/ValueOwnershipKindClassifier.cpp

@@ -49,6 +49,7 @@ CONSTANT_OWNERSHIP_INST(Guaranteed, LoadBorrow)
 CONSTANT_OWNERSHIP_INST(Owned, AllocBox)
 CONSTANT_OWNERSHIP_INST(Owned, AllocExistentialBox)
 CONSTANT_OWNERSHIP_INST(Owned, AllocRef)
+CONSTANT_OWNERSHIP_INST(Owned, ReallocRef)
 CONSTANT_OWNERSHIP_INST(Owned, AllocRefDynamic)
 CONSTANT_OWNERSHIP_INST(Trivial, AllocValueBuffer)
 CONSTANT_OWNERSHIP_INST(Owned, CopyBlock)

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -210,6 +210,7 @@ class SILCombiner :
   SILInstruction *visitIndexAddrInst(IndexAddrInst *IA);
   SILInstruction *visitAllocStackInst(AllocStackInst *AS);
   SILInstruction *visitAllocRefInst(AllocRefInst *AR);
+  SILInstruction *visitReallocRefInst(ReallocRefInst *AR);
   SILInstruction *visitSwitchEnumAddrInst(SwitchEnumAddrInst *SEAI);
   SILInstruction *visitInjectEnumAddrInst(InjectEnumAddrInst *IEAI);
   SILInstruction *visitPointerToAddressInst(PointerToAddressInst *PTAI);

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -465,6 +465,10 @@ SILInstruction *SILCombiner::visitAllocRefInst(AllocRefInst *AR) {
   return nullptr;
 }
 
+SILInstruction *SILCombiner::visitReallocRefInst(ReallocRefInst *RRI) {
+  return nullptr;
+}
+
 /// Returns the base address if \p val is an index_addr with constant index.
 static SILValue isConstIndexAddr(SILValue val, unsigned &index) {
   auto *IA = dyn_cast<IndexAddrInst>(val);

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -579,6 +579,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
   case SILInstructionKind::AllocBoxInst:
   case SILInstructionKind::AllocExistentialBoxInst:
   case SILInstructionKind::AllocRefInst:
+  case SILInstructionKind::ReallocRefInst:
   case SILInstructionKind::AllocRefDynamicInst:
   case SILInstructionKind::AllocStackInst:
   case SILInstructionKind::AllocValueBufferInst:

lib/Serialization/DeserializeSIL.cpp

@@ -1257,6 +1257,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
     }
     break;
   }
+  case SILInstructionKind::ReallocRefInst:
   case SILInstructionKind::AllocRefInst:
   case SILInstructionKind::AllocRefDynamicInst: {
     assert(RecordKind == SIL_ONE_TYPE_VALUES &&

lib/Serialization/SerializeSIL.cpp

@@ -827,6 +827,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
     break;
   }
   case SILInstructionKind::AllocRefInst:
+  case SILInstructionKind::ReallocRefInst:
   case SILInstructionKind::AllocRefDynamicInst: {
     const AllocRefInstBase *ARI = cast<AllocRefInstBase>(&SI);
     unsigned abbrCode = SILAbbrCodes[SILOneTypeValuesLayout::Code];

test/SIL/Parser/basic.sil

@@ -754,6 +754,19 @@ bb0(%0 : $Builtin.Word, %1 : $Builtin.Word):
   return %3 : $()
 }
 
+// CHECK-LABEL: sil @test_realloc_tail_elems
+sil @test_realloc_tail_elems : $@convention(thin) (Builtin.Word, Builtin.Word) -> () {
+bb0(%0 : $Builtin.Word, %1 : $Builtin.Word):
+  // CHECK: alloc_ref  [tail_elems $Val * %0 : $Builtin.Word] [tail_elems $Aleph * %1 : $Builtin.Word] $Class1
+  %2 = alloc_ref [tail_elems $Val * %0 : $Builtin.Word] [tail_elems $Aleph * %1 : $Builtin.Word] $Class1
+  // CHECK: %3 = realloc_ref [tail_elems $Val * %0 : $Builtin.Word] [tail_elems $Aleph * %  %1 : $Builtin.Word] %2, $Class1
+  %3 = realloc_ref [tail_elems $Val * %0 : $Builtin.Word] [tail_elems $Aleph * %  %1 : $Builtin.Word] %2, $Class1
+  // CHECK: dealloc_ref %3 : $Class1
+  dealloc_ref %3 : $Class1
+  %4 = tuple ()
+  return %4 : $()
+}
+
 // CHECK-LABEL: sil @test_tail_elems_dynamic
 sil @test_tail_elems_dynamic : $@convention(thin) (Builtin.Word, Builtin.Word, @thick Class1.Type) -> () {
 bb0(%0 : $Builtin.Word, %1 : $Builtin.Word, %2 : $@thick Class1.Type):