[DI] Add a way to find value of self in initializer context

This is staging for type wrappers that need to inject
`self.$storage = ...` call to user-defined initializers,
to be able to do that logic needs to be able to find
`self` that is being constructed.

Author: xedin

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -169,6 +169,25 @@ SILInstruction *DIMemoryObjectInfo::getFunctionEntryPoint() const {
   return &*getFunction().begin()->begin();
 }
 
+static SingleValueInstruction *
+getUninitializedValue(MarkUninitializedInst *MemoryInst) {
+  SILValue inst = MemoryInst;
+  if (auto *bbi = MemoryInst->getSingleUserOfType<BeginBorrowInst>()) {
+    inst = bbi;
+  }
+
+  if (SingleValueInstruction *svi =
+          inst->getSingleUserOfType<ProjectBoxInst>()) {
+    return svi;
+  }
+
+  return MemoryInst;
+}
+
+SingleValueInstruction *DIMemoryObjectInfo::getUninitializedValue() const {
+  return ::getUninitializedValue(MemoryInst);
+}
+
 /// Given a symbolic element number, return the type of the element.
 static SILType getElementTypeRec(TypeExpansionContext context,
                                  SILModule &Module, SILType T, unsigned EltNo,
@@ -478,6 +497,28 @@ bool DIMemoryObjectInfo::isElementLetProperty(unsigned Element) const {
   return false;
 }
 
+SingleValueInstruction *DIMemoryObjectInfo::findAnyInitSelfValue() const  {
+  // If the object is 'self', return its uninitialized value.
+  if (isAnyInitSelf())
+    return getUninitializedValue();
+
+  // Otherwise we need to scan entry block to find mark_uninitialized
+  // instruction that belongs to `self`.
+
+  auto *BB = getFunction().getEntryBlock();
+  if (!BB)
+    return nullptr;
+
+  for (auto &I : *BB) {
+    SILInstruction *Inst = &I;
+    if (auto *MUI = dyn_cast<MarkUninitializedInst>(Inst)) {
+      if (!MUI->isVar())
+        return ::getUninitializedValue(MUI);
+    }
+  }
+  return nullptr;
+}
+
 ConstructorDecl *DIMemoryObjectInfo::getActorInitSelf() const {
   // is it 'self'?
   if (!MemoryInst->isVar())

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -100,19 +100,7 @@ class DIMemoryObjectInfo {
   /// alloc_stack, this always just returns the actual mark_uninitialized
   /// instruction. For alloc_box though it returns the project_box associated
   /// with the memory info.
-  SingleValueInstruction *getUninitializedValue() const {
-    if (IsBox) {
-      SILValue inst = MemoryInst;
-      if (auto *bbi = MemoryInst->getSingleUserOfType<BeginBorrowInst>()) {
-        inst = bbi;
-      }
-      // TODO: consider just storing the ProjectBoxInst in this case.
-      SingleValueInstruction *svi = inst->getSingleUserOfType<ProjectBoxInst>();
-      assert(svi);
-      return svi;
-    }
-    return MemoryInst;
-  }
+  SingleValueInstruction *getUninitializedValue() const;
 
   /// Return the number of elements, without the extra "super.init" tracker in
   /// initializers of derived classes.
@@ -130,6 +118,10 @@ class DIMemoryObjectInfo {
   /// Return true if this is 'self' in any kind of initializer.
   bool isAnyInitSelf() const { return !MemoryInst->isVar(); }
 
+  /// Return uninitialized value of 'self' if current memory object
+  /// is located in an initializer (of any kind).
+  SingleValueInstruction *findAnyInitSelfValue() const;
+
   /// True if the memory object is the 'self' argument of a struct initializer.
   bool isStructInitSelf() const {
     if (MemoryInst->isRootSelf() || MemoryInst->isCrossModuleRootSelf()) {