[IRGen][Patch 2/2] Add IRGen support for SIL DIExpression

This patch is primarily doing two things:
 - Teach IRGen for some of the instructions to generate debug info based
   on SILDebugVariable rather than AST node, which is not always
   available when reading from SIL.
 - Generate corresponding `llvm.dbg.*` intrinsics and `!DIExpression`
   from the newly added SIL DIExpression.

Author: mshockwave

lib/IRGen/GenStruct.cpp

@@ -216,6 +216,13 @@ namespace {
       return nullptr;
     }
 
+    const TypeInfo *getFieldTypeInfo(IRGenModule &IGM, VarDecl *field) const {
+      auto &fieldInfo = getFieldInfo(field);
+      if (fieldInfo.isEmpty())
+        return nullptr;
+      return &fieldInfo.getTypeInfo();
+    }
+
     MemberAccessStrategy getFieldAccessStrategy(IRGenModule &IGM,
                                              SILType T, VarDecl *field) const {
       auto &fieldInfo = getFieldInfo(field);
@@ -1137,6 +1144,12 @@ Optional<unsigned> irgen::getPhysicalStructFieldIndex(IRGenModule &IGM,
   FOR_STRUCT_IMPL(IGM, baseType, getFieldIndexIfNotEmpty, field);
 }
 
+const TypeInfo *irgen::getPhysicalStructFieldTypeInfo(IRGenModule &IGM,
+                                                      SILType baseType,
+                                                      VarDecl *field) {
+  FOR_STRUCT_IMPL(IGM, baseType, getFieldTypeInfo, field);
+}
+
 void IRGenModule::emitStructDecl(StructDecl *st) {
   if (!IRGen.hasLazyMetadata(st)) {
     emitStructMetadata(*this, st);

lib/IRGen/GenStruct.h

@@ -34,7 +34,8 @@ namespace irgen {
   class IRGenFunction;
   class IRGenModule;
   class MemberAccessStrategy;
-  
+  class TypeInfo;
+
   Address projectPhysicalStructMemberAddress(IRGenFunction &IGF,
                                              Address base,
                                              SILType baseType,
@@ -58,6 +59,10 @@ namespace irgen {
   getPhysicalStructMemberAccessStrategy(IRGenModule &IGM,
                                         SILType baseType, VarDecl *field);
 
+  const TypeInfo *getPhysicalStructFieldTypeInfo(IRGenModule &IGM,
+                                                 SILType baseType,
+                                                 VarDecl *field);
+
   /// Returns the index of the element in the llvm struct type which represents
   /// \p field in \p baseType.
   ///
@@ -66,7 +71,6 @@ namespace irgen {
   llvm::Optional<unsigned> getPhysicalStructFieldIndex(IRGenModule &IGM,
                                                        SILType baseType,
                                                        VarDecl *field);
-
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/IRGenDebugInfo.cpp

@@ -17,6 +17,7 @@
 #define DEBUG_TYPE "debug-info"
 #include "IRGenDebugInfo.h"
 #include "GenOpaque.h"
+#include "GenStruct.h"
 #include "GenType.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/Expr.h"
@@ -189,6 +190,12 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
   llvm::DISubprogram *emitFunction(SILFunction &SILFn, llvm::Function *Fn);
   void emitArtificialFunction(IRBuilder &Builder, llvm::Function *Fn,
                               SILType SILTy);
+
+  void handleFragmentDIExpr(const SILDIExprOperand &CurDIExprOp,
+                            SmallVectorImpl<uint64_t> &Operands);
+  void buildDebugInfoExpression(const SILDebugVariable &VarInfo,
+                                SmallVectorImpl<uint64_t> &Operands);
+
   void emitVariableDeclaration(IRBuilder &Builder,
                                ArrayRef<llvm::Value *> Storage,
                                DebugTypeInfo Ty, const SILDebugScope *DS,
@@ -2330,10 +2337,59 @@ void IRGenDebugInfoImpl::emitArtificialFunction(IRBuilder &Builder,
   setCurrentLoc(Builder, Scope, ALoc);
 }
 
+void IRGenDebugInfoImpl::handleFragmentDIExpr(
+    const SILDIExprOperand &CurDIExprOp,
+    SmallVectorImpl<uint64_t> &Operands) {
+  assert(CurDIExprOp.getOperator() == SILDIExprOperator::Fragment);
+  // Expecting a VarDecl that points to a field in an struct
+  auto DIExprArgs = CurDIExprOp.args();
+  auto *VD = dyn_cast_or_null<VarDecl>(DIExprArgs.size()?
+                                       DIExprArgs[0].getAsDecl() : nullptr);
+  assert(VD && "Expecting a VarDecl as the operand for "
+               "DIExprOperator::Fragment");
+  // Translate the based type
+  DeclContext *ParentDecl = VD->getDeclContext();
+  SILType ParentSILType =
+      IGM.getLoweredType(ParentDecl->getDeclaredTypeInContext());
+  // Retrieve the offset & size of the field
+  llvm::Constant *Offset =
+      emitPhysicalStructMemberFixedOffset(IGM, ParentSILType, VD);
+  llvm::Type *FieldTy =
+      getPhysicalStructFieldTypeInfo(IGM, ParentSILType, VD)->getStorageType();
+  assert(Offset && FieldTy && "Non-fixed type?");
+
+  uint64_t SizeOfByte = CI.getTargetInfo().getCharWidth();
+  uint64_t SizeInBits = IGM.DataLayout.getTypeSizeInBits(FieldTy);
+  uint64_t OffsetInBits =
+      Offset->getUniqueInteger().getLimitedValue() * SizeOfByte;
+
+  // Translate to LLVM dbg intrinsic operands
+  Operands.push_back(llvm::dwarf::DW_OP_LLVM_fragment);
+  Operands.push_back(OffsetInBits);
+  Operands.push_back(SizeInBits);
+}
+
+void IRGenDebugInfoImpl::buildDebugInfoExpression(
+    const SILDebugVariable &VarInfo, SmallVectorImpl<uint64_t> &Operands) {
+  assert(VarInfo.DIExpr && "SIL debug info expression not found");
+
+  const auto &DIExpr = VarInfo.DIExpr;
+  for (const SILDIExprOperand &ExprOperand : DIExpr.operands()) {
+    switch (ExprOperand.getOperator()) {
+    case SILDIExprOperator::Fragment:
+      handleFragmentDIExpr(ExprOperand, Operands);
+      break;
+    default:
+      llvm_unreachable("Unrecoginized operator");
+    }
+  }
+}
+
 void IRGenDebugInfoImpl::emitVariableDeclaration(
     IRBuilder &Builder, ArrayRef<llvm::Value *> Storage, DebugTypeInfo DbgTy,
-    const SILDebugScope *DS, Optional<SILLocation> VarLoc, SILDebugVariable VarInfo,
-    IndirectionKind Indirection, ArtificialKind Artificial) {
+    const SILDebugScope *DS, Optional<SILLocation> DbgInstLoc,
+    SILDebugVariable VarInfo, IndirectionKind Indirection,
+    ArtificialKind Artificial) {
   assert(DS && "variable has no scope");
 
   if (Opts.DebugInfoLevel <= IRGenDebugInfoLevel::LineTables)
@@ -2348,7 +2404,7 @@ void IRGenDebugInfoImpl::emitVariableDeclaration(
 
   auto *Scope = dyn_cast_or_null<llvm::DILocalScope>(getOrCreateScope(DS));
   assert(Scope && "variable has no local scope");
-  auto Loc = getStartLocation(VarLoc);
+  auto DInstLoc = getStartLocation(DbgInstLoc);
 
   // FIXME: this should be the scope of the type's declaration.
   // If this is an argument, attach it to the current function scope.
@@ -2363,10 +2419,11 @@ void IRGenDebugInfoImpl::emitVariableDeclaration(
   if (VarInfo.Constant)
     DITy = DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_const_type, DITy);
 
-  unsigned Line = Loc.line;
+  unsigned DInstLine = DInstLoc.line;
 
   // Self is always an artificial argument, so are variables without location.
-  if (!Line || (VarInfo.ArgNo > 0 && VarInfo.Name == IGM.Context.Id_self.str()))
+  if (!DInstLine ||
+      (VarInfo.ArgNo > 0 && VarInfo.Name == IGM.Context.Id_self.str()))
     Artificial = ArtificialValue;
 
   llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
@@ -2376,12 +2433,35 @@ void IRGenDebugInfoImpl::emitVariableDeclaration(
   // This could be Opts.Optimize if we would also unique DIVariables here.
   bool Optimized = false;
   // Create the descriptor for the variable.
+  unsigned DVarLine = DInstLine;
+  if (VarInfo.Loc) {
+    auto DVarLoc = getStartLocation(VarInfo.Loc);
+    DVarLine = DVarLoc.line;
+  }
+  llvm::DIScope *VarScope = Scope;
+  if (VarInfo.Scope) {
+    if (auto *VS = dyn_cast_or_null<llvm::DILocalScope>(
+            getOrCreateScope(VarInfo.Scope)))
+      VarScope = VS;
+  }
   llvm::DILocalVariable *Var =
       (VarInfo.ArgNo > 0)
-          ? DBuilder.createParameterVariable(Scope, VarInfo.Name, VarInfo.ArgNo,
-                                             Unit, Line, DITy, Optimized, Flags)
-          : DBuilder.createAutoVariable(Scope, VarInfo.Name, Unit, Line, DITy,
-                                        Optimized, Flags);
+          ? DBuilder.createParameterVariable(VarScope, VarInfo.Name,
+                                             VarInfo.ArgNo, Unit, DVarLine,
+                                             DITy, Optimized, Flags)
+          : DBuilder.createAutoVariable(VarScope, VarInfo.Name, Unit, DVarLine,
+                                        DITy, Optimized, Flags);
+
+  auto appendDIExpression =
+      [&VarInfo, this](llvm::DIExpression *DIExpr) -> llvm::DIExpression * {
+    if (VarInfo.DIExpr) {
+      llvm::SmallVector<uint64_t, 2> Operands;
+      buildDebugInfoExpression(VarInfo, Operands);
+      if (Operands.size())
+        return llvm::DIExpression::append(DIExpr, Operands);
+    }
+    return DIExpr;
+  };
 
   // Running variables for the current/previous piece.
   bool IsPiece = Storage.size() > 1;
@@ -2413,16 +2493,21 @@ void IRGenDebugInfoImpl::emitVariableDeclaration(
       Operands.push_back(OffsetInBits);
       Operands.push_back(SizeInBits);
     }
-    emitDbgIntrinsic(Builder, Piece, Var, DBuilder.createExpression(Operands),
-                     Line, Loc.column, Scope, DS,
-                     Indirection == CoroDirectValue ||
-                         Indirection == CoroIndirectValue);
+    llvm::DIExpression *DIExpr = DBuilder.createExpression(Operands);
+    emitDbgIntrinsic(
+        Builder, Piece, Var,
+        // DW_OP_LLVM_fragment must be the last part of an DIExpr
+        // so we can't append more if IsPiece is true.
+        Operands.empty() || IsPiece ? DIExpr : appendDIExpression(DIExpr),
+        DInstLine, DInstLoc.column, Scope, DS,
+        Indirection == CoroDirectValue || Indirection == CoroIndirectValue);
   }
 
   // Emit locationless intrinsic for variables that were optimized away.
   if (Storage.empty())
     emitDbgIntrinsic(Builder, llvm::ConstantInt::get(IGM.Int64Ty, 0), Var,
-                     DBuilder.createExpression(), Line, Loc.column, Scope, DS,
+                     appendDIExpression(DBuilder.createExpression()), DInstLine,
+                     DInstLoc.column, Scope, DS,
                      Indirection == CoroDirectValue ||
                          Indirection == CoroIndirectValue);
 }
@@ -2438,7 +2523,8 @@ void IRGenDebugInfoImpl::emitDbgIntrinsic(
   auto *BB = Builder.GetInsertBlock();
 
   // An alloca may only be described by exactly one dbg.declare.
-  if (isa<llvm::AllocaInst>(Storage) && !llvm::FindDbgAddrUses(Storage).empty())
+  if (isa<llvm::AllocaInst>(Storage) &&
+      !llvm::FindDbgDeclareUses(Storage).empty())
     return;
 
   // A dbg.declare is only meaningful if there is a single alloca for

lib/IRGen/IRGenSIL.cpp

@@ -4734,8 +4734,13 @@ void IRGenSILFunction::visitDebugValueInst(DebugValueInst *i) {
   bool IsAnonymous = false;
   VarInfo->Name = getVarName(i, IsAnonymous);
   DebugTypeInfo DbgTy;
-  SILType SILTy = SILVal->getType();
-  auto RealTy = SILVal->getType().getASTType();
+  SILType SILTy;
+  if (auto MaybeSILTy = VarInfo->Type)
+    // If there is auxiliary type info, use it
+    SILTy = *MaybeSILTy;
+  else
+    SILTy = SILVal->getType();
+  auto RealTy = SILTy.getASTType();
   if (VarDecl *Decl = i->getDecl()) {
     DbgTy = DebugTypeInfo::getLocalVariable(
         Decl, RealTy, getTypeInfo(SILVal->getType()));
@@ -4765,10 +4770,6 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
   if (i->getDebugScope()->getInlinedFunction()->isTransparent())
     return;
 
-  VarDecl *Decl = i->getDecl();
-  if (!Decl)
-    return;
-
   auto SILVal = i->getOperand();
   if (isa<SILUndef>(SILVal))
     return;
@@ -4781,7 +4782,12 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
       (IsLoadablyByAddress) ? DirectValue : IndirectValue;
   VarInfo->Name = getVarName(i, IsAnonymous);
   auto *Addr = getLoweredAddress(SILVal).getAddress();
-  SILType SILTy = SILVal->getType();
+  SILType SILTy;
+  if (auto MaybeSILTy = VarInfo->Type)
+    // If there is auxiliary type info, use it
+    SILTy = *MaybeSILTy;
+  else
+    SILTy = SILVal->getType();
   auto RealType = SILTy.getASTType();
   if (CurSILFn->isAsync() && !i->getDebugScope()->InlinedCallSite) {
     Indirection = CoroIndirectValue;
@@ -4796,8 +4802,17 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
     }
   }
 
-  auto DbgTy = DebugTypeInfo::getLocalVariable(
-      Decl, RealType, getTypeInfo(SILVal->getType()));
+  DebugTypeInfo DbgTy;
+  if (VarDecl *Decl = i->getDecl())
+    DbgTy = DebugTypeInfo::getLocalVariable(Decl, RealType,
+                                            getTypeInfo(SILVal->getType()));
+  else if (i->getFunction()->isBare() && !SILTy.hasArchetype() &&
+           !VarInfo->Name.empty())
+    // Handle the cases that read from a SIL file
+    DbgTy = DebugTypeInfo::getFromTypeInfo(RealType, getTypeInfo(SILTy));
+  else
+    return;
+
   bindArchetypes(DbgTy.getType());
   if (!IGM.DebugInfo)
     return;
@@ -5128,18 +5143,26 @@ void IRGenSILFunction::emitDebugInfoForAllocStack(AllocStackInst *i,
             InCoroContext(*CurSILFn, *i) ? CoroIndirectValue : IndirectValue;
       }
 
-  if (!Decl)
-    return;
-
   // Ignore compiler-generated patterns but not optional bindings.
-  if (auto *Pattern = Decl->getParentPattern())
-    if (Pattern->isImplicit() &&
-        Pattern->getKind() != PatternKind::OptionalSome)
-      return;
+  if (Decl) {
+    if (auto *Pattern = Decl->getParentPattern()) {
+      if (Pattern->isImplicit() &&
+          Pattern->getKind() != PatternKind::OptionalSome)
+        return;
+    }
+  }
 
   SILType SILTy = i->getType();
   auto RealType = SILTy.getASTType();
-  auto DbgTy = DebugTypeInfo::getLocalVariable(Decl, RealType, type);
+  DebugTypeInfo DbgTy;
+  if (Decl) {
+    DbgTy = DebugTypeInfo::getLocalVariable(Decl, RealType, type);
+  } else if (i->getFunction()->isBare() && !SILTy.hasArchetype() &&
+             !VarInfo->Name.empty()) {
+    DbgTy = DebugTypeInfo::getFromTypeInfo(RealType, getTypeInfo(SILTy));
+  } else
+    return;
+
   // Async functions use the value of the artificial address.
   auto shadow = addr;
   if (CurSILFn->isAsync() && emitLifetimeExtendingUse(shadow) &&
@@ -5174,15 +5197,15 @@ void IRGenSILFunction::visitAllocStackInst(swift::AllocStackInst *i) {
   Address addr = stackAddr.getAddress();
 
   // Generate Debug Info.
-  if (!Decl)
+  if (!i->getVarInfo())
     return;
 
-  assert(i->getVarInfo() && "alloc_stack without debug info");
-
-  Type Desugared = Decl->getType()->getDesugaredType();
-  if (Desugared->getClassOrBoundGenericClass() ||
-      Desugared->getStructOrBoundGenericStruct())
-    zeroInit(dyn_cast<llvm::AllocaInst>(addr.getAddress()));
+  if (Decl) {
+    Type Desugared = Decl->getType()->getDesugaredType();
+    if (Desugared->getClassOrBoundGenericClass() ||
+        Desugared->getStructOrBoundGenericStruct())
+      zeroInit(dyn_cast<llvm::AllocaInst>(addr.getAddress()));
+  }
   emitDebugInfoForAllocStack(i, type, addr.getAddress());
 }
 

test/DebugInfo/debug_info_expression.sil

@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend %s -sil-verify-all -g -emit-sil -o - | %FileCheck %s
+// RUN: %target-swift-frontend %s -sil-verify-all -g -emit-sil -o - | %FileCheck --check-prefix=CHECK-SIL %s
+// RUN: %target-swift-frontend -disable-debugger-shadow-copies -primary-file %s -emit-ir -g -o - | %FileCheck %s
 import Builtin
 import Swift
 
@@ -12,11 +13,17 @@ sil_scope 1 { loc "file.swift":7:6 parent @test_fragment : $@convention(thin) ()
 sil hidden @test_fragment : $@convention(thin) () -> () {
 bb0:
   %2 = alloc_stack $MyStruct, var, name "my_struct", loc "file.swift":8:9, scope 1
+  // CHECK: %[[MY_STRUCT:.+]] = alloca %{{.*}}MyStruct
+  // CHECK: llvm.dbg.declare(metadata {{.*}}* %[[MY_STRUCT]], metadata ![[VAR_DECL_MD:[0-9]+]]
   %3 = struct_element_addr %2 : $*MyStruct, #MyStruct.x, loc "file.swift":9:17, scope 1
-  // CHECK: debug_value_addr %{{[0-9]+}} : $*Builtin.Int64
-  // CHECK-SAME:             (name "my_struct", loc "file.swift":8:9, scope {{[0-9]+}})
-  // CHECK-SAME              type $MyStruct, expr op_fragment:#MyStruct.x
+  // CHECK: %[[FIELD_X:.*]] = getelementptr {{.*}} %[[MY_STRUCT]]
+  // CHECK-SIL: debug_value_addr %{{[0-9]+}} : $*Builtin.Int64
+  // CHECK-SIL-SAME:            (name "my_struct", loc "file.swift":8:9, scope {{[0-9]+}})
+  // CHECK-SIL-SAME             type $MyStruct, expr op_fragment:#MyStruct.x
   debug_value_addr %3 : $*Builtin.Int64, var, (name "my_struct", loc "file.swift":8:9, scope 1), type $MyStruct, expr op_fragment:#MyStruct.x, loc "file.swift":9:17, scope 1
+  // CHECK: llvm.dbg.value(metadata {{.*}}* %[[FIELD_X]], metadata ![[VAR_DECL_MD]]
+  // CHECK-SAME:           !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
+  // CHECK-NOT:           ), !dbg ![[VAR_DECL_MD]]
   dealloc_stack %2 : $*MyStruct
   %r = tuple()
   return %r : $()

test/IRGen/lifetime.sil

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -gnone -emit-ir %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s -DINT=i%target-ptrsize
+// RUN: %target-swift-frontend -disable-debugger-shadow-copies -gnone -emit-ir %s | %FileCheck --check-prefix=CHECK --check-prefix=CHECK-%target-cpu %s -DINT=i%target-ptrsize
 
 // CHECK: [[OPAQUE:%swift.opaque]] = type opaque
 // CHECK: [[TYPE:%swift.type]] = type