Debug Info: Don't emit shadow stack copies for local variables.

The effect of this tiny change is that local variables will be described
by llvm.dbg.values, which will get lowered into an accurate location list
instead of a stack slot that is valid for the entire scope of the variable.
This means the debugger can now accurately track the liveness of variables
knowing exactly when they are initialized and when there values go away.
Function arguments are still kept in stack slots because (1) they are
already initialized at the function entry and (2) LLDB really needs self
to be available at all times for the expression evaluator.

This was made possible by recent advancements in LLVM such as the live
debug variables pass and various related bugfixes.

<rdar://problem/15746520>

Author: adrian-prantl

lib/IRGen/IRGenSIL.cpp

@@ -582,7 +582,7 @@ class IRGenSILFunction :
                               StringRef Name, unsigned ArgNo,
                               Alignment Align = Alignment(0)) {
     auto Ty = Storage->getType();
-    if (IGM.Opts.Optimize ||
+    if (IGM.Opts.Optimize || (ArgNo == 0) ||
         isa<llvm::AllocaInst>(Storage) ||
         isa<llvm::UndefValue>(Storage) ||
         Ty == IGM.RefCountedPtrTy) // No debug info is emitted for refcounts.

test/DebugInfo/WeakCapture.swift

@@ -10,10 +10,11 @@ func function() {
     let b = B()
 
   // Ensure that the local b and its weak copy are distinct local variables.
-  // CHECK:  %[[B:.*]] = alloca %C11WeakCapture1B*
-  // CHECK:  %[[BWEAK:.*]] = alloca %swift.weak*
-  // CHECK: call void @llvm.dbg.declare({{.*}}[[B]]
-  // CHECK: call void @llvm.dbg.declare({{.*}}[[BWEAK]]
+  // CHECK: call void @llvm.dbg.value(metadata %C11WeakCapture1B*
+  // CHECK-SAME:                      metadata [[B:.*]], metadata
+  // CHECK: call void @llvm.dbg.value(metadata %swift.weak*
+  // CHECK-NOT:                       metadata [[B]]
+  // CHECK: call
     A(handler: { [weak b] _ in
             if b != nil { }
         })

test/DebugInfo/arg-debug_value.swift

@@ -8,8 +8,7 @@ class Foo {
   var x: Int64
   // CHECK: define {{.*}}_TFC4main3FoocfT_S0_
   // CHECK: entry:
-  // CHECK-NEXT: %[[SELF:.*]] = alloca
-  // CHECK-NEXT: store %C4main3Foo* %0, %C4main3Foo** %[[SELF]]
-  // CHECK-NEXT: call void @llvm.dbg.declare({{.*}}%[[SELF]]
+  // CHECK-NEXT: call void @llvm.dbg.value(metadata %C4main3Foo* %0
+  // CHECK: ret %C4main3Foo* %0
   init () { x = g; g += 1 }
 }

test/DebugInfo/patternmatching.swift

@@ -25,13 +25,13 @@ switch p {
       // Verify that the branch has a location >= the cleanup.
       // SIL-CHECK-NEXT:  br{{.*}}line:[[@LINE-3]]:17:cleanup
       // CHECK-SCOPES: call {{.*}}markUsed
-      // CHECK-SCOPES: call void @llvm.dbg.declare({{.*}}metadata ![[X1:[0-9]+]]
+      // CHECK-SCOPES: call void @llvm.dbg.value({{.*}}metadata ![[X1:[0-9]+]]
       // CHECK-SCOPES-SAME:                        !dbg ![[X1LOC:[0-9]+]]
-      // CHECK-SCOPES: call void @llvm.dbg.declare
-      // CHECK-SCOPES: call void @llvm.dbg.declare({{.*}}metadata ![[X2:[0-9]+]]
+      // CHECK-SCOPES: call void @llvm.dbg.value
+      // CHECK-SCOPES: call void @llvm.dbg.value({{.*}}metadata ![[X2:[0-9]+]]
       // CHECK-SCOPES-SAME:                        !dbg ![[X2LOC:[0-9]+]]
-      // CHECK-SCOPES: call void @llvm.dbg.declare
-      // CHECK-SCOPES: call void @llvm.dbg.declare({{.*}}metadata ![[X3:[0-9]+]]
+      // CHECK-SCOPES: call void @llvm.dbg.value
+      // CHECK-SCOPES: call void @llvm.dbg.value({{.*}}metadata ![[X3:[0-9]+]]
       // CHECK-SCOPES-SAME:                        !dbg ![[X3LOC:[0-9]+]]
       // CHECK-SCOPES: !DILocalVariable(name: "x",
     case (let x, let y) where x == -y:

test/DebugInfo/value-update.sil

@@ -12,17 +12,15 @@ bb0:
   %1 = integer_literal $Builtin.Int64, 23
   %2 = struct $Int (%1 : $Builtin.Int64)
   debug_value %2 : $Int, var, name "v"
-  // CHECK: store i64 23, i64* %[[ALLOCA:.*]], align 8, !dbg
-  // CHECK: dbg.declare
+  // CHECK: call void @llvm.dbg.value(metadata i64 23,
   // function_ref StdlibUnittest._blackHole <A> (A) -> ()
   %5 = function_ref @_TF14StdlibUnittest10_blackHoleurFxT_ : $@convention(thin) <τ_0_0> (@in τ_0_0) -> () // user: %8
   %6 = tuple ()
   %7 = alloc_stack $()                            // users: %8, %9
   %8 = apply %5<()>(%7) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> ()
   dealloc_stack %7 : $*()        // id: %9
 
-  // CHECK: store i64 42, i64* %[[ALLOCA]], align 8, !dbg
-  // CHECK-NOT: dbg.declare
+  // CHECK: call void @llvm.dbg.value(metadata i64 42,
   %9 = integer_literal $Builtin.Int64, 42         // user: %10
   %10 = struct $Int (%9 : $Builtin.Int64)         // user: %11
   debug_value %10 : $Int, var, name "v"