[WIP]: try to fix things & add many debug logs

Author: jamieQ

lib/SILGen/SILGenDecl.cpp

@@ -40,6 +40,8 @@
 #include "llvm/Support/ErrorHandling.h"
 #include <iterator>
 
+#define DEBUG_TYPE "SILGenDecl"
+
 using namespace swift;
 using namespace Lowering;
 
@@ -781,6 +783,7 @@ class LetValueInitialization : public Initialization {
     // There are four cases we need to handle here: parameters, initialized (or
     // bound) decls, uninitialized ones, and async let declarations.
     bool needsTemporaryBuffer;
+    bool isUninitialized = false;
 
     assert(!isa<ParamDecl>(vd)
            && "should not bind function params on this path");
@@ -789,12 +792,14 @@ class LetValueInitialization : public Initialization {
       // If this is a let-value without an initializer, then we need a temporary
       // buffer.  DI will make sure it is only assigned to once.
       needsTemporaryBuffer = true;
+      isUninitialized = true;
     } else if (vd->isAsyncLet()) {
       // If this is an async let, treat it like a let-value without an
       // initializer. The initializer runs concurrently in a child task,
       // and value will be initialized at the point the variable in the
       // async let is used.
       needsTemporaryBuffer = true;
+      isUninitialized = true;
     } else {
       // If this is a let with an initializer or bound value, we only need a
       // buffer if the type is address only or is noncopyable.
@@ -805,6 +810,12 @@ class LetValueInitialization : public Initialization {
               lowering->getLoweredType().isMoveOnly(/*orWrapped=*/false);
     }
 
+//    auto parentInit = vd->getParentInitializer();
+//    if (isa<CallExpr>(parentInit)) {
+//      auto fn = cast<CallExpr>(parentInit)->getSemanticFn();
+//      isUninitialized = isa<AbstractClosureExpr>(fn);
+//    }
+
     // Make sure that we have a non-address only type when binding a
     // @_noImplicitCopy let.
     if (lowering->isAddressOnly() && vd->isNoImplicitCopy()) {
@@ -813,6 +824,10 @@ class LetValueInitialization : public Initialization {
     }
 
     if (needsTemporaryBuffer) {
+      LLVM_DEBUG({
+        llvm::dbgs() << "JQ: need tmp buffer\n";
+        vd->dump(llvm::dbgs());
+      });
       bool lexicalLifetimesEnabled =
           SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule());
       auto lifetime = SGF.F.getLifetime(vd, lowering->getLoweredType());
@@ -824,7 +839,8 @@ class LetValueInitialization : public Initialization {
 
       // Ensure DI always checks this to avoid cases where an address-only
       // value is referenced in a closure that is part of its initializer.
-      address = SGF.B.createMarkUninitializedVar(vd, address);
+      if (true || isUninitialized)
+        address = SGF.B.createMarkUninitializedVar(vd, address);
 
       DestroyCleanup = SGF.enterDormantTemporaryCleanup(address, *lowering);
       SGF.VarLocs[vd] = SILGenFunction::VarLoc(address,
@@ -834,7 +850,7 @@ class LetValueInitialization : public Initialization {
     // inactive until the variable is initialized: if control flow exits the
     // before the value is bound, we don't want to destroy the value.
     //
-    // Cleanups are required for all lexically scoped variables to delimite
+    // Cleanups are required for all lexically scoped variables to delimit
     // the variable scope, even if the cleanup does nothing.
     SGF.Cleanups.pushCleanupInState<DestroyLocalVariable>(
       CleanupState::Dormant, vd);

lib/SILGen/SILGenFunction.cpp

@@ -590,6 +590,16 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     break;
   }
 
+  LLVM_DEBUG({
+    llvm::dbgs() << "JQ: emit captures running\n";
+    for (auto capture : captureInfo.getCaptures()) {
+      llvm::dbgs() << "  cap: '" << capture.getDecl()->getName() << "'\n";
+    }
+    llvm::dbgs()
+      << "  canGuarantee: '" << canGuarantee << "'\n"
+      << "  capCanEscape: '" << captureCanEscape << "'\n";
+  });
+
   auto expansion = getTypeExpansionContext();
 
   for (auto capture : captureInfo.getCaptures()) {
@@ -609,6 +619,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     if (capture.isOpaqueValue() || capture.isPackElement()) {
       capturedArgs.push_back(
           emitRValueAsSingleValue(capture.getExpr()).ensurePlusOne(*this, loc));
+      LLVM_DEBUG(llvm::dbgs() << "JQ: cap emit early ret: opaque || pack\n");
       continue;
     }
 
@@ -632,6 +643,52 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     auto valueType = FunctionDC->mapTypeIntoContext(
       interfaceType->getReferenceStorageReferent());
 
+    LLVM_DEBUG(
+    {
+      llvm::dbgs() << "=== DEBUG: VarLocs contents for capture of '"
+      << vd->getBaseIdentifier() << "' ===\n";
+      llvm::dbgs() << "Total entries in VarLocs: " << VarLocs.size() << "\n";
+
+      for (auto &entry : VarLocs) {
+        auto *var = entry.first;
+        auto &loc = entry.second;
+
+        llvm::dbgs() << "  - Variable: " << var->getBaseIdentifier() << "\n";
+        //      llvm::errs() << "    Type: " << var->getType() << "\n";
+        llvm::dbgs() << "    Value type: " << loc.value->getType() << "\n";
+        llvm::dbgs() << "    Value kind: ";
+
+        if (isa<SILUndef>(loc.value)) {
+          llvm::dbgs() << "SILUndef (UNINITIALIZED)\n";
+        } else if (isa<SILArgument>(loc.value)) {
+          llvm::dbgs() << "SILArgument\n";
+        } else if (isa<AllocStackInst>(loc.value)) {
+          llvm::dbgs() << "AllocStackInst\n";
+        } else if (isa<AllocBoxInst>(loc.value)) {
+          llvm::dbgs() << "AllocBoxInst\n";
+        } else {
+          llvm::dbgs() << "some other inst\n";
+        }
+
+        if (loc.box) {
+          llvm::dbgs() << "    Has box: yes\n";
+        }
+
+        llvm::dbgs() << "\n";
+      }
+
+      llvm::dbgs() << "Looking for variable: " << vd->getBaseIdentifier() << "\n";
+      auto found = VarLocs.find(vd);
+      if (found == VarLocs.end()) {
+        llvm::dbgs() << "  Result: NOT FOUND in VarLocs\n";
+      } else {
+        llvm::dbgs() << "  Result: FOUND in VarLocs\n";
+        llvm::dbgs() << "  Value is undef: "
+        << (isa<SILUndef>(found->second.value) ? "YES" : "NO") << "\n";
+      }
+      llvm::dbgs() << "===================================\n\n";
+    });
+
     //
     // If we haven't emitted the captured value yet, we're forming a closure
     // to a local function before all of its captures have been emitted. Eg,
@@ -695,6 +752,12 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     // expansion context without opaque archetype substitution.
     auto getAddressValue = [&](SILValue entryValue, bool forceCopy,
                                bool forLValue) -> SILValue {
+      LLVM_DEBUG({
+        llvm::dbgs() << "JQ: get addr value, force copy: " << forceCopy
+          << ", for lval: " << forLValue << "\n";
+        entryValue->getDefiningInstruction()->print(llvm::dbgs());
+      });
+
       if (!SGM.M.useLoweredAddresses() && !forLValue && !isPack) {
         // In opaque values mode, addresses aren't used except by lvalues.
         auto &lowering = getTypeLowering(entryValue->getType());
@@ -775,6 +838,11 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     auto &Entry = found->second;
     auto val = Entry.value;
 
+    LLVM_DEBUG({
+      auto capKind = SGM.Types.getDeclCaptureKind(capture, expansion);
+      llvm::dbgs() << "JQ: cap kind:: " << (unsigned)capKind << "\n";
+    });
+
     switch (SGM.Types.getDeclCaptureKind(capture, expansion)) {
     case CaptureKind::Constant: {
       assert(!isPack);
@@ -855,6 +923,12 @@ void SILGenFunction::emitCaptures(SILLocation loc,
         }
         capturedArgs.push_back(ManagedValue::forOwnedAddressRValue(
             addr, CleanupHandle::invalid()));
+
+//        LLVM_DEBUG({
+//          llvm::dbgs() << "JQ: adding escape to mark for: \n";
+//          val->getDefiningInstruction()->print(llvm::dbgs());
+//        });
+//        escapesToMark.push_back(val);
       }
       break;
     }

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -823,6 +823,27 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
       continue;
     }
 
+    if (false || (isa<UnconditionalCheckedCastAddrInst>(User) ||
+                  isa<CheckedCastAddrBranchInst>(User))) {
+      LLVM_DEBUG({
+        llvm::dbgs() << "JQ: DI found unchecked addr cast:\n"
+        << Op;
+      });
+
+      DIUseKind Kind;
+      Kind = DIUseKind::Initialization;
+//      if (Op->getOperandNumber() == 0)
+//        Kind = DIUseKind::Load;
+//      else
+//        Kind = InStructSubElement ? DIUseKind::PartialStore
+//                                  : DIUseKind::Initialization;
+
+      // TODO: what about enum sub elt? do we need to even special case things here?
+
+      addElementUses(BaseEltNo, PointeeType, User, Kind);
+      continue;
+    }
+
     // Look through mark_unresolved_non_copyable_value. To us, it is not
     // interesting.
     if (auto *mmi = dyn_cast<MarkUnresolvedNonCopyableValueInst>(User)) {

test/SILOptimizer/definite_init_address_only_let.swift

@@ -48,4 +48,25 @@ func uninit_closure_reference() {
   let initMe = passthrough { initMe }
   // expected-error @-1 {{constant 'initMe' used before being initialized}}
   // expected-note @-2 {{defined here}}
+
+  let inline = { () -> Any in inline }()
+  // expected-error @-1 {{constant 'inline' used before being initialized}}
+  // expected-note @-2 {{defined here}}
+
+  // these should not regress
+  func castAny(_ a: Any) {
+    let directUncond = a as! Int
+    _ = directUncond
+
+    let directCond = a as? Int
+    _ = directCond
+
+    let twoPhaseUncond: Int
+    twoPhaseUncond = a as! Int
+    _ = twoPhaseUncond
+
+    let twoPhasCond: Int?
+    twoPhasCond = a as? Int
+    _ = twoPhasCond
+  }
 }