SIL: add the end_init_let_ref instruction

This instructions marks the point where all let-fields of a class are initialized.
This is important to ensure the correctness of ``ref_element_addr [immutable]`` for let-fields,
because in the initializer of a class, its let-fields are not immutable, yet.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StripObjectHeaders.swift

@@ -55,6 +55,7 @@ private struct IsBareObjectWalker : ValueDefUseWalker {
          is BranchInst, is CondBranchInst, is SwitchEnumInst,
          is UpcastInst, is UncheckedRefCastInst,
          is BeginDeallocRefInst,
+         is EndInitLetRefInst,
          is EndCOWMutationInst:
       return walkDownDefault(value: operand, path: path)
     default:

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -545,6 +545,7 @@ extension Value {
     while true {
       switch value {
       case is BeginBorrowInst, is CopyValueInst, is MoveValueInst,
+           is EndInitLetRefInst,
            is BeginDeallocRefInst,
            is UpcastInst, is UncheckedRefCastInst, is EndCOWMutationInst:
         value = (value as! Instruction).operands[0].value

SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift

@@ -349,7 +349,7 @@ extension ValueDefUseWalker {
         return unmatchedPath(value: operand, path: path)
       }
     case is BeginBorrowInst, is CopyValueInst, is MoveValueInst,
-      is UpcastInst, is UncheckedRefCastInst, is EndCOWMutationInst,
+      is UpcastInst, is UncheckedRefCastInst, is EndCOWMutationInst, is EndInitLetRefInst,
       is RefToBridgeObjectInst, is BridgeObjectToRefInst, is MarkUnresolvedNonCopyableValueInst:
       return walkDownUses(ofValue: (instruction as! SingleValueInstruction), path: path)
     case let beginDealloc as BeginDeallocRefInst:
@@ -660,7 +660,7 @@ extension ValueUseDefWalker {
     case let oer as OpenExistentialRefInst:
       return walkUp(value: oer.existential, path: path.push(.existential, index: 0))
     case is BeginBorrowInst, is CopyValueInst, is MoveValueInst,
-      is UpcastInst, is UncheckedRefCastInst, is EndCOWMutationInst,
+      is UpcastInst, is UncheckedRefCastInst, is EndCOWMutationInst, is EndInitLetRefInst,
       is BeginDeallocRefInst,
       is RefToBridgeObjectInst, is BridgeObjectToRefInst, is MarkUnresolvedNonCopyableValueInst:
       return walkUp(value: (def as! Instruction).operands[0].value, path: path)

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -123,6 +123,11 @@ public struct Builder {
     return notifyNew(beginDealloc.getAs(BeginDeallocRefInst.self))
   }
 
+  public func createEndInitLetRef(operand: Value) -> EndInitLetRefInst {
+    let endInit = bridged.createEndInitLetRef(operand.bridged)
+    return notifyNew(endInit.getAs(EndInitLetRefInst.self))
+  }
+
   @discardableResult
   public func createStrongRetain(operand: Value) -> StrongRetainInst {
     let retain = bridged.createStrongRetain(operand.bridged)

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -309,6 +309,8 @@ final public class BeginDeallocRefInst : SingleValueInstruction {
   public var allocation: AllocRefInstBase { operands[1].value as! AllocRefInstBase }
 }
 
+final public class EndInitLetRefInst : SingleValueInstruction, UnaryInstruction {}
+
 public class RefCountingInst : Instruction, UnaryInstruction {
   public var isAtomic: Bool { bridged.RefCountingInst_getIsAtomic() }
 }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -51,6 +51,7 @@ public func registerSILClasses() {
   register(DebugStepInst.self)
   register(UnconditionalCheckedCastAddrInst.self)
   register(BeginDeallocRefInst.self)
+  register(EndInitLetRefInst.self)
   register(EndApplyInst.self)
   register(AbortApplyInst.self)
   register(StrongRetainInst.self)

docs/SIL.rst

@@ -5131,6 +5131,21 @@ implications and it's purpose is purly to enforce that the object allocation
 is present in the same function and trivially visible from the
 ``begin_dealloc_ref`` instruction.
 
+end_init_let_ref
+````````````````
+::
+
+  %1 = end_init_let_ref %0 : $T
+  // $T must be a reference type.
+
+Marks the point where all let-fields of a class are initialized.
+
+Returns the reference operand. Technically, the returned reference is the same
+as the operand. But it's important that optimizations see the result as a
+different SSA value than the operand. This is important to ensure the
+correctness of ``ref_element_addr [immutable]`` for let-fields, because in the
+initializer of a class, its let-fields are not immutable, yet.
+
 strong_copy_unowned_value
 `````````````````````````
 ::
@@ -6574,6 +6589,10 @@ is null.
 The ``immutable`` attribute specifies that all loads of the same instance
 variable from the same class reference operand are guaranteed to yield the
 same value.
+The ``immutable`` attribute is used to reference COW buffer elements after an
+``end_cow_mutation`` and before a ``begin_cow_mutation``.
+The attribute is also used for let-fields of a class after an
+``end_init_let_ref`` and before a ``begin_dealloc_ref``.
 
 ref_tail_addr
 `````````````

include/swift/SIL/SILBridging.h

@@ -1142,6 +1142,11 @@ struct BridgedBuilder{
     return {builder().createBeginDeallocRef(regularLoc(), reference.getSILValue(), allocation.getSILValue())};
   }
 
+  SWIFT_IMPORT_UNSAFE
+  BridgedInstruction createEndInitLetRef(BridgedValue op) const {
+    return {builder().createEndInitLetRef(regularLoc(), op.getSILValue())};
+  }
+
   SWIFT_IMPORT_UNSAFE
   BridgedInstruction createStrongRetain(BridgedValue op) const {
     auto b = builder();

include/swift/SIL/SILBuilder.h

@@ -1599,6 +1599,12 @@ class SILBuilder {
         getSILDebugLocation(Loc), reference, allocation));
   }
 
+  EndInitLetRefInst *createEndInitLetRef(SILLocation Loc,
+                                             SILValue operand) {
+    return insert(new (getModule()) EndInitLetRefInst(
+        getSILDebugLocation(Loc), operand));
+  }
+
   ObjectInst *createObject(SILLocation Loc, SILType Ty,
                            ArrayRef<SILValue> Elements,
                            unsigned NumBaseElements) {

include/swift/SIL/SILCloner.h

@@ -2130,6 +2130,15 @@ SILCloner<ImplClass>::visitBeginDeallocRefInst(BeginDeallocRefInst *Inst) {
                                                getOpValue(Inst->getAllocation())));
 }
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitEndInitLetRefInst(EndInitLetRefInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createEndInitLetRef(getOpLocation(Inst->getLoc()),
+                                          getOpValue(Inst->getOperand())));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitObjectInst(ObjectInst *Inst) {