[SIL] InitAccessors: Introduce a new Out kind to MarkUninitializedInst

`Out` marks indirect results that have to be fully initialized
before their lifetime ends.

Author: xedin

include/swift/SIL/SILBuilder.h

@@ -1018,7 +1018,11 @@ class SILBuilder {
                                                          SILValue src) {
     return createMarkUninitialized(Loc, src, MarkUninitializedInst::RootSelf);
   }
-  
+  MarkUninitializedInst *createMarkUninitializedOut(SILLocation Loc,
+                                                    SILValue src) {
+    return createMarkUninitialized(Loc, src, MarkUninitializedInst::Out);
+  }
+
   MarkFunctionEscapeInst *createMarkFunctionEscape(SILLocation Loc,
                                                    ArrayRef<SILValue> vars) {
     return insert(

include/swift/SIL/SILInstruction.h

@@ -5029,6 +5029,10 @@ class MarkUninitializedInst
     /// DelegatingSelfAllocated designates "self" in a delegating class
     /// initializer where memory has already been allocated.
     DelegatingSelfAllocated,
+
+    /// Out designates an indirectly returned result.
+    /// This is the result that has to be checked for initialization.
+    Out,
   };
 private:
   Kind ThisKind;
@@ -5043,6 +5047,7 @@ class MarkUninitializedInst
   Kind getMarkUninitializedKind() const { return ThisKind; }
 
   bool isVar() const { return ThisKind == Var; }
+  bool isOut() const { return ThisKind == Out; }
   bool isRootSelf() const {
     return ThisKind == RootSelf;
   }

lib/SIL/IR/SILPrinter.cpp

@@ -1797,6 +1797,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     case MarkUninitializedInst::DelegatingSelfAllocated:
       *this << "[delegatingselfallocated] ";
       break;
+    case MarkUninitializedInst::Out:
+      *this << "[out] ";
+      break;
     }
     *this << getIDAndType(MU->getOperand());
     printForwardingOwnershipKind(MU, MU->getOperand());

lib/SIL/Parser/ParseSIL.cpp

@@ -4489,6 +4489,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       Kind = MarkUninitializedInst::DelegatingSelf;
     else if (KindId.str() == "delegatingselfallocated")
       Kind = MarkUninitializedInst::DelegatingSelfAllocated;
+    else if (KindId.str() == "out")
+      Kind = MarkUninitializedInst::Out;
     else {
       P.diagnose(KindLoc, diag::expected_tok_in_sil_instr,
                  "var, rootself, crossmodulerootself, derivedself, "

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -200,6 +200,7 @@ class DIMemoryObjectInfo {
   bool isNonDelegatingInit() const {
     switch (MemoryInst->getMarkUninitializedKind()) {
     case MarkUninitializedInst::Var:
+    case MarkUninitializedInst::Out:
       return false;
     case MarkUninitializedInst::RootSelf:
     case MarkUninitializedInst::CrossModuleRootSelf:

lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp

@@ -183,6 +183,7 @@ bool isUseOfSelfInInitializer(Operand *oper) {
     if (auto *MUI = dyn_cast<MarkUninitializedInst>(value)) {
       switch (MUI->getMarkUninitializedKind()) {
       case MarkUninitializedInst::Kind::Var:
+      case MarkUninitializedInst::Kind::Out:
         return false;
       case MarkUninitializedInst::Kind::RootSelf:
       case MarkUninitializedInst::Kind::CrossModuleRootSelf:

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 = 789; // assign or init instruction
+const uint16_t SWIFTMODULE_VERSION_MINOR = 790; // add `out` kind to mark uninitialized instruction
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///