[IRGenSIL] Force early materialization of liverange-extended values

At -Onone, we may opt to extend the liverange of a value by inserting
fake uses of the value in blocks which postdominate its def. This keeps
values available throughout the entirety of a function when stepping
through it in a debugger.

This patch makes it so that we also insert a fake use at the start of a
value's lifetime. This forces early materialization of the value, i.e it
becomes available for inspection in a debugger as soon as it's defined.

This is useful when a value has no uses except fake uses. In such cases,
ISel may (correctly!) decide to materialize the value at the end of its
scope. This is really unintuitive and unhelpful for users, because you
need to be done stepping through the value's scope before you can
inspect it.

For the same reasons, forcing early materialization is also useful when
a value *does* have uses. Consider:

  let d = ...
  print("Here is the value of d: \(d)")

Without early materialization, if you set a breakpoint on the line
containing the print, you would not be able to inspect "d". That's
because "d" would be materialized right before string interpolation
happens, which is *after* the breakpoint PC.

rdar://38465084

Author: vedantk

lib/IRGen/IRGenSIL.cpp

@@ -28,6 +28,7 @@
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Transforms/Utils/Local.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include "swift/Basic/ExternalUnion.h"
@@ -707,18 +708,13 @@ class IRGenSILFunction :
           // The current basic block must be a successor of the dbg.value().
           continue;
 
-        auto It = llvm::BasicBlock::iterator(Var);
-        for (auto I = std::next(It), E = BB->end(); I != E; ++I) {
-          auto *DVI = dyn_cast<llvm::DbgValueInst>(I);
-          if (DVI && DVI->getValue() == Var)
+        llvm::SmallVector<llvm::DbgValueInst *, 4> DbgValues;
+        llvm::findDbgValues(DbgValues, Var);
+        for (auto *DVI : DbgValues)
+          if (DVI->getParent() == BB)
             IGM.DebugInfo->getBuilder().insertDbgValueIntrinsic(
                 DVI->getValue(), DVI->getVariable(), DVI->getExpression(),
                 DVI->getDebugLoc(), &*CurBB->getFirstInsertionPt());
-          else
-            // Found all dbg.value intrinsics describing this location.
-            // FIXME: How do we know that there aren't more dbg.values?
-            break;
-        }
       }
     }
   }
@@ -772,10 +768,18 @@ class IRGenSILFunction :
     if (ArgNo == 0)
       // Otherwise only if debug value range extension is not feasible.
       if (!needsShadowCopy(Storage)) {
-        // Mark for debug value range extension unless this is a constant.
-        if (auto *Value = dyn_cast<llvm::Instruction>(Storage))
-          if (ValueVariables.insert(Value).second)
-            ValueDomPoints.push_back({Value, getActiveDominancePoint()});
+        // Mark for debug value range extension unless this is a constant, or
+        // unless it's not possible to emit lifetime-extending uses for this.
+        if (auto *Value = dyn_cast<llvm::Instruction>(Storage)) {
+          // Emit a use at the start of the storage lifetime to force early
+          // materialization. This makes variables available for inspection as
+          // soon as they are defined.
+          bool ExtendedLifetime = emitLifetimeExtendingUse(Value);
+          if (ExtendedLifetime)
+            if (ValueVariables.insert(Value).second)
+              ValueDomPoints.push_back({Value, getActiveDominancePoint()});
+        }
+
         return Storage;
       }
     return emitShadowCopy(Storage, Scope, Name, ArgNo, Align);

test/DebugInfo/liverange-extension.swift

@@ -1,27 +1,63 @@
 // RUN: %target-swift-frontend %s -g -emit-ir -o - | %FileCheck %s
 
+// REQUIRES: CPU=x86_64
+//
+// We require x86_64 to make the test easier to read. Without this,
+// writing check lines that ensure our asm gadgets match up with the
+// right values is painfully hard to do.
+
 func use<T>(_ x: T) {}
 
 func getInt32() -> Int32 { return -1 }
 
+// CHECK-LABEL: define {{.*}}rangeExtension
 public func rangeExtension(_ b: Bool) {
-  // CHECK: define {{.*}}rangeExtension
   let i = getInt32()
-  // CHECK: llvm.dbg.value(metadata i32 [[I:.*]], metadata {{.*}}, metadata
+  // CHECK: [[I:%.*]] = call swiftcc i32 @"{{.*}}getInt32
+  // CHECK-NEXT: [[I_ZEXT:%.*]] = zext i32 [[I]] to i64
+  // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[I_ZEXT]])
+  // CHECK-NEXT: llvm.dbg.value(metadata i32 [[I]], metadata [[MD_I:!.*]], metadata
+
   use(i)
+
+  // CHECK: br i1
+
   if b {
+    // CHECK: llvm.dbg.value(metadata i32 [[I]], metadata [[MD_I]]
+
     let j = getInt32()
-    // CHECK: llvm.dbg.value(metadata i32 [[I]], metadata {{.*}}, metadata
-    // CHECK: llvm.dbg.value(metadata i32 [[J:.*]], metadata {{.*}}, metadata
+    // CHECK: [[J:%.*]] = call swiftcc i32 @"{{.*}}getInt32
+    // CHECK-NEXT: [[J_ZEXT:%.*]] = zext i32 [[J]] to i64
+    // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[J_ZEXT]])
+    // CHECK: llvm.dbg.value(metadata i32 [[J]], metadata [[MD_J:!.*]], metadata
+
     use(j)
-    // CHECK-DAG: {{(asm sideeffect "", "r".*)|(zext i32)}} [[J]]
-    // CHECK-DAG: asm sideeffect "", "r"
+    // CHECK: call swiftcc void @"{{.*}}use
+
+    // CHECK: [[I_ZEXT:%.*]] = zext i32 [[I]] to i64
+    // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[I_ZEXT]])
+    // CHECK-NEXT: [[J_ZEXT:%.*]] = zext i32 [[J]] to i64
+    // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[J_ZEXT]])
+
+    // CHECK: br label
   }
+
+  // CHECK-NOT: llvm.dbg.value(metadata i32 [[J]]
+  // CHECK: llvm.dbg.value(metadata i32 [[I]]
+
   let z = getInt32()
+  // CHECK: [[Z:%.*]] = call swiftcc i32 @"{{.*}}getInt32
+  // CHECK: llvm.dbg.value(metadata i32 [[Z]], metadata [[MD_Z:!.*]], metadata
+
   use(z)
-  // CHECK-NOT: llvm.dbg.value(metadata i32 [[J]], metadata {{.*}}, metadata
-  // CHECK-DAG: llvm.dbg.value(metadata i32 [[I]], metadata {{.*}}, metadata
-  // CHECK-DAG: llvm.dbg.value(metadata i32 [[Z:.*]], metadata {{.*}}, metadata
-  // CHECK-DAG: {{(asm sideeffect "", "r".*)|(zext i32)}} [[I]]
-  // CHECK-DAG: asm sideeffect "", "r"
+  // CHECK: call swiftcc void @"{{.*}}use
+
+  // CHECK: [[I_ZEXT:%.*]] = zext i32 [[I]] to i64
+  // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[I_ZEXT]])
+  // CHECK-NEXT: [[Z_ZEXT:%.*]] = zext i32 [[Z]] to i64
+  // CHECK-NEXT: call void asm sideeffect "", "r"(i64 [[Z_ZEXT]])
 }
+
+// CHECK-DAG: [[MD_I]] = !DILocalVariable(name: "i"
+// CHECK-DAG: [[MD_J]] = !DILocalVariable(name: "j"
+// CHECK-DAG: [[MD_Z]] = !DILocalVariable(name: "z"