[SILOptimizer] Don't lower AssignInst in DI

Author: Azoy

include/swift/SIL/SILInstruction.h

@@ -3603,6 +3603,22 @@ class EndUnpairedAccessInst
   }
 };
 
+enum class PartialInitializationKind {
+  /// Unknown initialization method
+  Unknown,
+
+  /// The box contains a fully-initialized value.
+  IsNotInitialization,
+
+  /// The box contains a class instance that we own, but the instance has
+  /// not been initialized and should be freed with a special SIL
+  /// instruction made for this purpose.
+  IsReinitialization,
+
+  /// The box contains an undefined value that should be ignored.
+  IsInitialization,
+};
+
 /// AssignInst - Represents an abstract assignment to a memory location, which
 /// may either be an initialization or a store sequence.  This is only valid in
 /// Raw SIL.
@@ -3612,6 +3628,7 @@ class AssignInst
   friend SILBuilder;
 
   FixedOperandList<2> Operands;
+  PartialInitializationKind InitKind;
 
   AssignInst(SILDebugLocation DebugLoc, SILValue Src, SILValue Dest);
 
@@ -3628,6 +3645,9 @@ class AssignInst
 
   ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+
+  PartialInitializationKind getInitKind() const { return InitKind; }
+  void setInitKind(PartialInitializationKind initKind) { InitKind = initKind; }
 };
 
 /// Indicates that a memory location is uninitialized at this point and needs to

lib/SIL/SILInstructions.cpp

@@ -813,7 +813,8 @@ StringRef swift::getSILAccessEnforcementName(SILAccessEnforcement enforcement) {
 }
 
 AssignInst::AssignInst(SILDebugLocation Loc, SILValue Src, SILValue Dest)
-    : InstructionBase(Loc), Operands(this, Src, Dest) {}
+    : InstructionBase(Loc), Operands(this, Src, Dest),
+      InitKind(PartialInitializationKind::Unknown) {}
 
 MarkFunctionEscapeInst *
 MarkFunctionEscapeInst::create(SILDebugLocation Loc,

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1884,20 +1884,16 @@ void LifetimeChecker::updateInstructionForInitState(DIMemoryUse &Use) {
     Use.Inst = nullptr;
     NonLoadUses.erase(Inst);
 
-    PartialInitializationKind PartialInitKind;
-
     if (TheMemory.isClassInitSelf() &&
         Use.Kind == DIUseKind::SelfInit) {
       assert(InitKind == IsInitialization);
-      PartialInitKind = PartialInitializationKind::IsReinitialization;
+      AI->setInitKind(PartialInitializationKind::IsReinitialization);
     } else {
-      PartialInitKind = (InitKind == IsInitialization
-                         ? PartialInitializationKind::IsInitialization
-                         : PartialInitializationKind::IsNotInitialization);
+      AI->setInitKind((InitKind == IsInitialization
+                      ? PartialInitializationKind::IsInitialization
+                      : PartialInitializationKind::IsNotInitialization));
     }
 
-    SILBuilderWithScope B(Inst);
-    lowerAssignInstruction(B, AI, PartialInitKind);
     return;
   }
 

lib/SILOptimizer/Mandatory/MandatoryOptUtils.cpp

@@ -38,30 +38,36 @@ using namespace swift;
 /// Emit the sequence that an assign instruction lowers to once we know
 /// if it is an initialization or an assignment.  If it is an assignment,
 /// a live-in value can be provided to optimize out the reload.
-void swift::lowerAssignInstruction(SILBuilderWithScope &B, AssignInst *Inst,
-                                   PartialInitializationKind isInitialization) {
+void swift::lowerAssignInstruction(SILBuilderWithScope &B, AssignInst *Inst) {
   LLVM_DEBUG(llvm::dbgs() << "  *** Lowering [isInit="
-                          << unsigned(isInitialization)
+                          << unsigned(Inst->getInitKind())
                           << "]: " << *Inst << "\n");
 
   ++NumAssignRewritten;
 
   SILValue Src = Inst->getSrc();
   SILLocation Loc = Inst->getLoc();
+  PartialInitializationKind initKind = Inst->getInitKind();
 
-  if (isInitialization == PartialInitializationKind::IsInitialization ||
+  // Unknown initKind is considered unprocessed. Just lower it as
+  // NotInitialization
+  if (initKind == PartialInitializationKind::Unknown) {
+    initKind = PartialInitializationKind::IsNotInitialization;
+  }
+
+  if (initKind == PartialInitializationKind::IsInitialization ||
       Inst->getDest()->getType().isTrivial(Inst->getModule())) {
 
     // If this is an initialization, or the storage type is trivial, we
     // can just replace the assignment with a store.
-    assert(isInitialization != PartialInitializationKind::IsReinitialization);
+    assert(initKind != PartialInitializationKind::IsReinitialization);
     B.createTrivialStoreOr(Loc, Src, Inst->getDest(),
                            StoreOwnershipQualifier::Init);
     Inst->eraseFromParent();
     return;
   }
 
-  if (isInitialization == PartialInitializationKind::IsReinitialization) {
+  if (initKind == PartialInitializationKind::IsReinitialization) {
     // We have a case where a convenience initializer on a class
     // delegates to a factory initializer from a protocol extension.
     // Factory initializers give us a whole new instance, so the existing
@@ -81,7 +87,7 @@ void swift::lowerAssignInstruction(SILBuilderWithScope &B, AssignInst *Inst,
     return;
   }
 
-  assert(isInitialization == PartialInitializationKind::IsNotInitialization);
+  assert(initKind == PartialInitializationKind::IsNotInitialization);
   // Otherwise, we need to replace the assignment with the full
   // load/store/release dance. Note that the new value is already
   // considered to be retained (by the semantics of the storage type),

lib/SILOptimizer/Mandatory/MandatoryOptUtils.h

@@ -24,23 +24,8 @@ namespace swift {
 class SILBuilderWithScope;
 class AssignInst;
 
-enum class PartialInitializationKind {
-  /// The box contains a fully-initialized value.
-  IsNotInitialization,
-
-  /// The box contains a class instance that we own, but the instance has
-  /// not been initialized and should be freed with a special SIL
-  /// instruction made for this purpose.
-  IsReinitialization,
-
-  /// The box contains an undefined value that should be ignored.
-  IsInitialization,
-};
-
-void lowerAssignInstruction(SILBuilderWithScope &B, AssignInst *Inst,
-                            PartialInitializationKind isInitialization)
+void lowerAssignInstruction(SILBuilderWithScope &B, AssignInst *Inst)
     LLVM_LIBRARY_VISIBILITY;
-
 } // namespace swift
 
 #endif

lib/SILOptimizer/Mandatory/RawSILInstLowering.cpp

@@ -30,11 +30,16 @@ static bool lowerRawSILOperations(SILFunction &Fn) {
       SILInstruction *Inst = &*I;
       ++I;
 
-      // Unprocessed assigns just lower into assignments, not initializations.
+      // Lower 'assign' depending on initialization kind defined by definite
+      // initialization.
+      //
+      // Unknown is considered unprocessed and is just NotInitialization
+      // Initialization becomes an init store instruction
+      // Reinititialization becomes a load, store, and a dealloc_partial_ref
+      // NotInitialization becomes a take load, and an init store
       if (auto *AI = dyn_cast<AssignInst>(Inst)) {
         SILBuilderWithScope B(AI);
-        lowerAssignInstruction(B, AI,
-                               PartialInitializationKind::IsNotInitialization);
+        lowerAssignInstruction(B, AI);
         // Assign lowering may split the block. If it did,
         // reset our iteration range to the block after the insertion.
         if (B.getInsertionBB() != &BB)