SILOptimizer: Turn type(of: self) from uninitialized self stack space into the self argument.

Before we changed convenience inits into allocating entry points, we allowed type(of: self) to be invoked on the uninitialized object, which was fine. This no longer Just Works when self doesn't even exist before `self.init` is called, but to maintain the old semantics and source compatibility, we can still just use the metatype value we were passed in.

Author: jckarter

lib/SILOptimizer/Mandatory/DIMemoryUseCollectorOwnership.cpp

@@ -1476,15 +1476,15 @@ void ElementUseCollector::collectClassSelfUses(
 }
 
 //===----------------------------------------------------------------------===//
-//                    DelegatingValueTypeInitUseCollector
+//                         DelegatingInitUseCollector
 //===----------------------------------------------------------------------===//
 
 static void
-collectValueTypeDelegatingInitUses(const DIMemoryObjectInfo &TheMemory,
-                                   DIElementUseInfo &UseInfo,
-                                   SingleValueInstruction *I) {
+collectDelegatingInitUses(const DIMemoryObjectInfo &TheMemory,
+                          DIElementUseInfo &UseInfo,
+                          SingleValueInstruction *I) {
   for (auto *Op : I->getUses()) {
-    auto *User = Op->getUser();
+    SILInstruction *User = Op->getUser();
 
     // destroy_addr is a release of the entire value. This can result from an
     // early release due to a conditional initializer.
@@ -1519,13 +1519,48 @@ collectValueTypeDelegatingInitUses(const DIMemoryObjectInfo &TheMemory,
 
     // Look through begin_access
     if (auto *BAI = dyn_cast<BeginAccessInst>(User)) {
-      collectValueTypeDelegatingInitUses(TheMemory, UseInfo, BAI);
+      collectDelegatingInitUses(TheMemory, UseInfo, BAI);
       continue;
     }
 
     // Ignore end_access
     if (isa<EndAccessInst>(User))
       continue;
+    
+    // A load of the value that's only used to handle a type(of:) query before
+    // self has been initialized can just use the initializer's metatype
+    // argument. For value types, there's no metatype subtyping to worry about,
+    // and for class convenience initializers, `self` notionally has the
+    // original Self type as its dynamic type before theoretically being
+    // rebound.
+    //
+    // This is necessary for source compatibility; previously, convenience
+    // initializers behaved like in Objective-C where the initializer received
+    // an uninitialized object to fill in, and type(of: self) worked by asking
+    // for the dynamic type of that uninitialized object.
+    if (isa<LoadInst>(User)) {
+      auto UserVal = cast<SingleValueInstruction>(User);
+      if (UserVal->hasOneUse()
+          && isa<ValueMetatypeInst>(UserVal->getSingleUse()->get())) {
+        Kind = DIUseKind::LoadForTypeOfSelf;
+      }
+    }
+    // value_metatype may appear on a borrowed load, in which case there'll
+    // be an end_borrow use in addition to the value_metatype.
+    if (isa<LoadBorrowInst>(User)) {
+      auto UserVal = cast<SingleValueInstruction>(User);
+      bool onlyUseIsValueMetatype = true;
+      for (auto use : UserVal->getUses()) {
+        if (isa<EndBorrowInst>(use->getUser())
+            || isa<ValueMetatypeInst>(use->getUser()))
+          continue;
+        onlyUseIsValueMetatype = false;
+        break;
+      }
+      if (onlyUseIsValueMetatype) {
+        Kind = DIUseKind::LoadForTypeOfSelf;
+      }
+    }
 
     // We can safely handle anything else as an escape.  They should all happen
     // after self.init is invoked.
@@ -1534,33 +1569,33 @@ collectValueTypeDelegatingInitUses(const DIMemoryObjectInfo &TheMemory,
 }
 
 //===----------------------------------------------------------------------===//
-//                   DelegatingClassInitElementUseCollector
+//                        ClassInitElementUseCollector
 //===----------------------------------------------------------------------===//
 
 namespace {
 
-class DelegatingClassInitElementUseCollector {
+class ClassInitElementUseCollector {
   const DIMemoryObjectInfo &TheMemory;
   DIElementUseInfo &UseInfo;
 
 public:
-  DelegatingClassInitElementUseCollector(const DIMemoryObjectInfo &TheMemory,
+  ClassInitElementUseCollector(const DIMemoryObjectInfo &TheMemory,
                                          DIElementUseInfo &UseInfo)
       : TheMemory(TheMemory), UseInfo(UseInfo) {}
 
   void collectClassInitSelfUses();
 
   // *NOTE* Even though this takes a SILInstruction it actually only accepts
   // load_borrow and load instructions. This is enforced via an assert.
-  void collectDelegatingClassInitSelfLoadUses(MarkUninitializedInst *MUI,
-                                              SingleValueInstruction *LI);
+  void collectClassInitSelfLoadUses(MarkUninitializedInst *MUI,
+                                    SingleValueInstruction *LI);
 };
 
 } // end anonymous namespace
 
 /// collectDelegatingClassInitSelfUses - Collect uses of the self argument in a
 /// delegating-constructor-for-a-class case.
-void DelegatingClassInitElementUseCollector::collectClassInitSelfUses() {
+void ClassInitElementUseCollector::collectClassInitSelfUses() {
   // When we're analyzing a delegating constructor, we aren't field sensitive at
   // all.  Just treat all members of self as uses of the single
   // non-field-sensitive value.
@@ -1668,8 +1703,7 @@ void DelegatingClassInitElementUseCollector::collectClassInitSelfUses() {
 
     // Loads of the box produce self, so collect uses from them.
     if (isa<LoadInst>(User) || isa<LoadBorrowInst>(User)) {
-      collectDelegatingClassInitSelfLoadUses(MUI,
-                                        cast<SingleValueInstruction>(User));
+      collectClassInitSelfLoadUses(MUI, cast<SingleValueInstruction>(User));
       continue;
     }
 
@@ -1691,8 +1725,8 @@ void DelegatingClassInitElementUseCollector::collectClassInitSelfUses() {
   gatherDestroysOfContainer(MUI, UseInfo);
 }
 
-void DelegatingClassInitElementUseCollector::
-collectDelegatingClassInitSelfLoadUses(MarkUninitializedInst *MUI,
+void ClassInitElementUseCollector::
+collectClassInitSelfLoadUses(MarkUninitializedInst *MUI,
                                        SingleValueInstruction *LI) {
   assert(isa<LoadBorrowInst>(LI) || isa<LoadInst>(LI));
 
@@ -1794,13 +1828,12 @@ void swift::ownership::collectDIElementUsesFrom(
     // at all. Just treat all members of self as uses of the single
     // non-field-sensitive value.
     assert(MemoryInfo.NumElements == 1 && "delegating inits only have 1 bit");
-    collectValueTypeDelegatingInitUses(MemoryInfo, UseInfo,
-                                       MemoryInfo.MemoryInst);
+    collectDelegatingInitUses(MemoryInfo, UseInfo, MemoryInfo.MemoryInst);
     return;
   }
 
   if (shouldPerformClassInitSelf(MemoryInfo)) {
-    DelegatingClassInitElementUseCollector UseCollector(MemoryInfo, UseInfo);
+    ClassInitElementUseCollector UseCollector(MemoryInfo, UseInfo);
     UseCollector.collectClassInitSelfUses();
     return;
   }

lib/SILOptimizer/Mandatory/DIMemoryUseCollectorOwnership.h

@@ -116,8 +116,12 @@ class DIMemoryObjectInfo {
     return false;
   }
 
-  /// True if the memory object is the 'self' argument of a class initializer.
+  /// True if the memory object is the 'self' argument of a class designated
+  /// initializer.
   bool isClassInitSelf() const {
+    if (isDelegatingInit())
+      return false;
+      
     if (!MemoryInst->isVar()) {
       if (auto decl = getType()->getAnyNominal()) {
         if (isa<ClassDecl>(decl)) {
@@ -226,7 +230,11 @@ enum DIUseKind {
 
   /// This instruction is a call to 'self.init' in a delegating initializer,
   /// or a call to 'super.init' in a designated initializer of a derived class..
-  SelfInit
+  SelfInit,
+  
+  /// This instruction is a load that's only used to answer a `type(of: self)`
+  /// question.
+  LoadForTypeOfSelf,
 };
 
 /// This struct represents a single classified access to the memory object

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -480,6 +480,7 @@ namespace {
 
     void handleStoreUse(unsigned UseID);
     void handleLoadUse(unsigned UseID);
+    void handleLoadForTypeOfSelfUse(const DIMemoryUse &Use);
     void handleInOutUse(const DIMemoryUse &Use);
     void handleEscapeUse(const DIMemoryUse &Use);
 
@@ -542,8 +543,21 @@ LifetimeChecker::LifetimeChecker(const DIMemoryObjectInfo &TheMemory,
     // Keep track of all the uses that aren't loads or escapes.  These are
     // important uses that we'll visit, but we don't consider them definition
     // points for liveness computation purposes.
-    if (Use.Kind == DIUseKind::Load || Use.Kind == DIUseKind::Escape)
+    switch (Use.Kind) {
+    case DIUseKind::Load:
+    case DIUseKind::LoadForTypeOfSelf:
+    case DIUseKind::Escape:
       continue;
+    case DIUseKind::Assign:
+    case DIUseKind::IndirectIn:
+    case DIUseKind::InitOrAssign:
+    case DIUseKind::InOutArgument:
+    case DIUseKind::Initialization:
+    case DIUseKind::InOutSelfArgument:
+    case DIUseKind::PartialStore:
+    case DIUseKind::SelfInit:
+      break;
+    }
 
     NonLoadUses[Use.Inst] = ui;
 
@@ -790,6 +804,8 @@ void LifetimeChecker::doIt() {
     case DIUseKind::SelfInit:
       handleSelfInitUse(Use);
       break;
+    case DIUseKind::LoadForTypeOfSelf:
+      handleLoadForTypeOfSelfUse(Use);
     }
   }
 
@@ -826,6 +842,28 @@ void LifetimeChecker::handleLoadUse(unsigned UseID) {
     return handleLoadUseFailure(Use, IsSuperInitComplete, FailedSelfUse);
 }
 
+void LifetimeChecker::handleLoadForTypeOfSelfUse(const DIMemoryUse &Use) {
+  bool IsSuperInitComplete, FailedSelfUse;
+  // If the value is not definitively initialized, replace the
+  // value_metatype instruction with the metatype argument that was passed into
+  // the initializer.
+  if (!isInitializedAtUse(Use, &IsSuperInitComplete, &FailedSelfUse)) {
+    auto load = cast<SingleValueInstruction>(Use.Inst);
+    
+    ValueMetatypeInst *valueMetatype = nullptr;
+    for (auto use : load->getUses()) {
+      valueMetatype = dyn_cast<ValueMetatypeInst>(use->getUser());
+      if (valueMetatype)
+        break;
+    }
+    assert(valueMetatype);
+    auto metatypeArgument = load->getFunction()->getEntryBlock()->getArguments()
+      .back();
+    replaceAllSimplifiedUsesAndErase(valueMetatype, metatypeArgument,
+                                     [](SILInstruction*) { });
+  }
+}
+
 void LifetimeChecker::emitSelfConsumedDiagnostic(SILInstruction *Inst) {
   if (!shouldEmitError(Inst))
     return;
@@ -1930,12 +1968,13 @@ void LifetimeChecker::processUninitializedRelease(SILInstruction *Release,
     auto SILMetatypeTy = SILType::getPrimitiveObjectType(MetatypeTy);
     SILValue Metatype;
 
-    // In an inherited convenience initializer, we must use the dynamic
-    // type of the object since nothing is initialized yet.
-    if (TheMemory.isDelegatingInit())
-      Metatype = B.createValueMetatype(Loc, SILMetatypeTy, Pointer);
-    else
-      Metatype = B.createMetatype(Loc, SILMetatypeTy);
+    // A convenience initializer should never deal in partially allocated
+    // objects.
+    assert(!TheMemory.isDelegatingInit());
+
+    // In a designated initializer, we know the class of the thing
+    // we're cleaning up statically.
+    Metatype = B.createMetatype(Loc, SILMetatypeTy);
 
     // We've already destroyed any instance variables initialized by this
     // constructor, now destroy instance variables initialized by subclass