Merge pull request #2926 from adrian-prantl/master

Author: swift-ci

lib/IRGen/GenDecl.cpp

@@ -1395,7 +1395,7 @@ llvm::GlobalVariable *LinkInfo::createVariable(IRGenModule &IGM,
   if (IGM.DebugInfo && !DbgTy.isNull() && ForDefinition)
     IGM.DebugInfo->emitGlobalVariableDeclaration(
         var, DebugName.empty() ? getName() : DebugName, getName(), DbgTy,
-        DebugLoc);
+        var->hasInternalLinkage(), DebugLoc);
 
   return var;
 }

lib/IRGen/GenInit.cpp

@@ -21,9 +21,11 @@
 #include "swift/SIL/SILGlobalVariable.h"
 #include "llvm/IR/GlobalVariable.h"
 
+#include "DebugTypeInfo.h"
 #include "Explosion.h"
 #include "GenHeap.h"
 #include "GenTuple.h"
+#include "IRGenDebugInfo.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
 #include "FixedTypeInfo.h"
@@ -37,8 +39,17 @@ Address IRGenModule::emitSILGlobalVariable(SILGlobalVariable *var) {
 
   // If the variable is empty in all resilience domains, don't actually emit it;
   // just return undef.
-  if (ti.isKnownEmpty(ResilienceExpansion::Minimal))
+  if (ti.isKnownEmpty(ResilienceExpansion::Minimal)) {
+    if (DebugInfo && var->getDecl()) {
+      auto Zero = llvm::ConstantInt::get(Int64Ty, 0);
+      DebugTypeInfo DbgTy(var->getDecl(), var->getLoweredType().getSwiftType(),
+                          Int8Ty, Size(0), Alignment(1));
+      DebugInfo->emitGlobalVariableDeclaration(
+          Zero, var->getDecl()->getName().str(), "", DbgTy,
+          var->getLinkage() != SILLinkage::Public, SILLocation(var->getDecl()));
+    }
     return ti.getUndefAddress();
+  }
 
   /// Get the global variable.
   Address addr = getAddrOfSILGlobalVariable(var, ti,

lib/IRGen/IRGenDebugInfo.cpp

@@ -949,8 +949,9 @@ void IRGenDebugInfo::emitVariableDeclaration(
 
   // Emit locationless intrinsic for variables that were optimized away.
   if (Storage.size() == 0) {
-    auto *undef = llvm::UndefValue::get(DbgTy.StorageType);
-    emitDbgIntrinsic(BB, undef, Var, DBuilder.createExpression(), Line,
+    auto Zero =
+        llvm::ConstantInt::get(llvm::Type::getInt64Ty(M.getContext()), 0);
+    emitDbgIntrinsic(BB, Zero, Var, DBuilder.createExpression(), Line,
                      Loc.Column, Scope, DS);
   }
 }
@@ -982,10 +983,11 @@ void IRGenDebugInfo::emitDbgIntrinsic(llvm::BasicBlock *BB,
 }
 
 
-void IRGenDebugInfo::emitGlobalVariableDeclaration(llvm::GlobalValue *Var,
+void IRGenDebugInfo::emitGlobalVariableDeclaration(llvm::Constant *Var,
                                                    StringRef Name,
                                                    StringRef LinkageName,
                                                    DebugTypeInfo DbgTy,
+                                                   bool IsLocalToUnit,
                                                    Optional<SILLocation> Loc) {
   if (Opts.DebugInfoKind == IRGenDebugInfoKind::LineTables)
     return;
@@ -1003,7 +1005,7 @@ void IRGenDebugInfo::emitGlobalVariableDeclaration(llvm::GlobalValue *Var,
 
   // Emit it as global variable of the current module.
   DBuilder.createGlobalVariable(MainModule, Name, LinkageName, File, L.Line, Ty,
-                                Var->hasInternalLinkage(), Var, nullptr);
+                                IsLocalToUnit, Var, nullptr);
 }
 
 StringRef IRGenDebugInfo::getMangledName(DebugTypeInfo DbgTy) {
@@ -1259,12 +1261,6 @@ llvm::DIType *IRGenDebugInfo::createType(DebugTypeInfo DbgTy,
   // to emit the (target!) size of the underlying basic type.
   uint64_t SizeOfByte = CI.getTargetInfo().getCharWidth();
   uint64_t SizeInBits = DbgTy.size.getValue() * SizeOfByte;
-  // Prefer the actual storage size over the DbgTy.
-  if (DbgTy.StorageType && DbgTy.StorageType->isSized()) {
-    uint64_t Storage = IGM.DataLayout.getTypeSizeInBits(DbgTy.StorageType);
-    if (Storage)
-      SizeInBits = Storage;
-  }
   uint64_t AlignInBits = DbgTy.align.getValue() * SizeOfByte;
   unsigned Encoding = 0;
   unsigned Flags = 0;

lib/IRGen/IRGenDebugInfo.h

@@ -181,9 +181,10 @@ class IRGenDebugInfo {
                         const SILDebugScope *DS);
 
   /// Create debug metadata for a global variable.
-  void emitGlobalVariableDeclaration(llvm::GlobalValue *Storage, StringRef Name,
+  void emitGlobalVariableDeclaration(llvm::Constant *Storage, StringRef Name,
                                      StringRef LinkageName,
                                      DebugTypeInfo DebugType,
+                                     bool IsLocalToUnit,
                                      Optional<SILLocation> Loc);
 
   /// Emit debug metadata for type metadata (for generic types). So meta.

test/DebugInfo/letclause.swift

@@ -6,7 +6,8 @@ func peek() -> Symbol? { return Symbol() }
 
 func foo() {
 // CHECK: define {{.*}}foo
-// CHECK: call void @llvm.dbg.declare(metadata %V9letclause6Symbol undef, metadata ![[S:.*]], metadata !{{[0-9]+}})
+// CHECK: call void @llvm.dbg.value(metadata i{{.*}} 0,
+// CHECK-SAME:                        metadata ![[S:.*]], metadata !{{[0-9]+}})
 // CHECK: ![[S]] = !DILocalVariable(name: "s"
 // CHECK-SAME:                      line: [[@LINE+1]],
   while let s = peek() {

test/DebugInfo/nostorage.swift

@@ -1,28 +1,40 @@
-// RUN: %target-swift-frontend %s -emit-ir -g -o - | FileCheck %s
+// RUN: %target-swift-frontend %s -emit-ir -g -o %t
+// RUN: cat %t | FileCheck %s --check-prefix=CHECK1
+// RUN: cat %t | FileCheck %s --check-prefix=CHECK2
+// RUN: cat %t | FileCheck %s --check-prefix=CHECK3
 
-func markUsed<T>(_ t: T) {}
+func used<T>(_ t: T) {}
 
-class AClass {
-  func f () -> Int64 { return 1 }
+public class Foo {
+    func foo() {
+      { [weak self] in
+      // CHECK1: call void @llvm.dbg.value(metadata i{{.*}} 0,
+      // CHECK1-SAME:                      metadata ![[TYPE:.*]], metadata
+      // CHECK1: ![[TYPE]] = !DILocalVariable(name: "type",
+      // CHECK1-SAME:                         line: [[@LINE+4]],
+      // CHECK1-SAME:                         type: ![[FOO:[0-9]+]]
+      // CHECK1: ![[FOO]] = !DICompositeType(tag: DW_TAG_structure_type,
+      // CHECK1-SAME:                        line: [[@LINE+1]], align: 8, flags:
+            let type = self.dynamicType
+            used(type)
+        }()
+    }
 }
 
-class AnotherClass : AClass {
-  override func f() -> Int64 { return 2 }
-}
-
-struct AStruct {
-  func f() -> Int64 { return 3 }
-}
+struct AStruct {}
 
-// CHECK: define hidden void @_TF9nostorage3appFT_T_()
-func app() {
-  var ac: AClass = AnotherClass()
+// CHECK2: define{{.*}}app
+public func app() {
   // No members? No storage! Emitted as a constant 0, because.
-  // CHECK: call void @llvm.dbg.value(metadata {{.*}}, i64 0, metadata ![[AT:.*]], metadata !{{[0-9]+}}), !dbg
-  // CHECK: ![[AT]] = !DILocalVariable(name: "at",
-  // CHECK-SAME:                       line: [[@LINE+1]]
+  // CHECK2: call void @llvm.dbg.value(metadata i{{.*}} 0,
+  // CHECK2-SAME:                      metadata ![[AT:.*]], metadata
+  // CHECK2: ![[AT]] = !DILocalVariable(name: "at",{{.*}}line: [[@LINE+1]]
   var at = AStruct()
-  markUsed("\(ac.f()) \(at.f())")
+  
+  used(at)
 }
 
-app()
+public enum empty { case exists }
+public let globalvar = empty.exists
+// CHECK3: !DIGlobalVariable(name: "globalvar", {{.*}}line: [[@LINE-1]],
+// CHECK3-SAME:          isLocal: false, isDefinition: true, variable: i64 0)

test/DebugInfo/self-nostorage.swift

@@ -3,8 +3,8 @@
 public struct S {
   func f() {
     // CHECK: define {{.*}}_TFV4main1S1ffT_T_
-    // CHECK: call void @llvm.dbg.declare(metadata %V4main1S undef,
-    // CHECK-SAME:                        metadata ![[SELF:[0-9]+]]
+    // CHECK: call void @llvm.dbg.value(metadata i{{.*}} 0,
+    // CHECK-SAME:                      metadata ![[SELF:[0-9]+]]
     // CHECK: ![[SELF]] = !DILocalVariable(name: "self", arg: 1,
   }
 }